mono_inst_set_src_registers (struct MonoInst * ins, int * regs)
{
  int D.29025;
  int D.29026;
  int D.29027;

  D.29025 = *regs;
  ins->sreg1 = D.29025;
  D.29026 = MEM[(int *)regs + 4B];
  ins->sreg2 = D.29026;
  D.29027 = MEM[(int *)regs + 8B];
  ins->sreg3 = D.29027;
}


mono_alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.29028;

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


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.29030;
  unsigned int D.29031;
  unsigned int D.29032;
  unsigned int D.29033;

  D.29031 = cfg->next_vreg;
  D.29032 = D.29031;
  D.29033 = D.29032 + 1;
  cfg->next_vreg = D.29033;
  D.29030 = D.29032;
  return D.29030;
}


mono_alloc_freg (struct MonoCompile * cfg)
{
  guint32 D.29035;

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


alloc_freg (struct MonoCompile * cfg)
{
  int D.29037;
  guint32 D.29040;
  unsigned int D.29041;
  unsigned int D.29042;
  unsigned int D.29043;

  D.29037 = mono_arch_is_soft_float ();
  if (D.29037 != 0) goto <D.29038>; else goto <D.29039>;
  <D.29038>:
  D.29040 = alloc_lreg (cfg);
  return D.29040;
  <D.29039>:
  D.29041 = cfg->next_vreg;
  D.29042 = D.29041;
  D.29043 = D.29042 + 1;
  cfg->next_vreg = D.29043;
  D.29040 = D.29042;
  return D.29040;
}


mono_arch_is_soft_float ()
{
  gboolean D.29045;

  D.29045 = 0;
  return D.29045;
}


alloc_lreg (struct MonoCompile * cfg)
{
  guint32 D.29047;
  unsigned int D.29048;
  unsigned int D.29049;
  unsigned int D.29050;

  D.29048 = cfg->next_vreg;
  D.29049 = D.29048;
  D.29050 = D.29049 + 1;
  cfg->next_vreg = D.29050;
  D.29047 = D.29049;
  return D.29047;
}


mono_alloc_preg (struct MonoCompile * cfg)
{
  guint32 D.29052;

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


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

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


mono_alloc_dreg (struct MonoCompile * cfg, MonoStackType stack_type)
{
  guint32 D.29056;

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


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

  switch (stack_type) <default: <D.24591>, case 1: <D.24584>, case 2: <D.24589>, case 3: <D.24585>, case 4: <D.24588>, case 5: <D.24586>, case 6: <D.24587>, case 7: <D.24590>>
  <D.24584>:
  <D.24585>:
  D.29058 = alloc_ireg (cfg);
  return D.29058;
  <D.24586>:
  D.29058 = alloc_ireg_mp (cfg);
  return D.29058;
  <D.24587>:
  D.29058 = alloc_ireg_ref (cfg);
  return D.29058;
  <D.24588>:
  D.29058 = alloc_freg (cfg);
  return D.29058;
  <D.24589>:
  D.29058 = alloc_lreg (cfg);
  return D.29058;
  <D.24590>:
  D.29058 = alloc_ireg (cfg);
  return D.29058;
  <D.24591>:
  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.29058 = 4294967295;
  return D.29058;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.29060;
  long unsigned int D.29061;
  long unsigned int D.29062;
  guint32 D.29065;
  int vreg;

  D.29060 = alloc_ireg (cfg);
  vreg = (int) D.29060;
  D.29061 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.29062 = D.29061 & 128;
  if (D.29062 != 0) goto <D.29063>; else goto <D.29064>;
  <D.29063>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.29064>:
  D.29065 = (guint32) vreg;
  return D.29065;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.29067;
  long unsigned int D.29068;
  long unsigned int D.29069;
  guint32 D.29072;
  int vreg;

  D.29067 = alloc_ireg (cfg);
  vreg = (int) D.29067;
  D.29068 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.29069 = D.29068 & 128;
  if (D.29069 != 0) goto <D.29070>; else goto <D.29071>;
  <D.29070>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.29071>:
  D.29072 = (guint32) vreg;
  return D.29072;
}


mono_alloc_ireg_ref (struct MonoCompile * cfg)
{
  guint32 D.29074;

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


mono_alloc_ireg_mp (struct MonoCompile * cfg)
{
  guint32 D.29076;

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


mono_alloc_ireg_copy (struct MonoCompile * cfg, guint32 vreg)
{
  unsigned int D.29079;
  gboolean * D.29081;
  long unsigned int D.29082;
  long unsigned int D.29083;
  gboolean * D.29084;
  int D.29085;
  guint32 D.29087;
  unsigned int D.29089;
  gboolean * D.29091;
  gboolean * D.29092;
  int D.29093;

  D.29079 = cfg->vreg_is_ref_len;
  if (D.29079 > vreg) goto <D.29080>; else goto <D.29078>;
  <D.29080>:
  D.29081 = cfg->vreg_is_ref;
  D.29082 = (long unsigned int) vreg;
  D.29083 = D.29082 * 4;
  D.29084 = D.29081 + D.29083;
  D.29085 = *D.29084;
  if (D.29085 != 0) goto <D.29086>; else goto <D.29078>;
  <D.29086>:
  D.29087 = alloc_ireg_ref (cfg);
  return D.29087;
  <D.29078>:
  D.29089 = cfg->vreg_is_mp_len;
  if (D.29089 > vreg) goto <D.29090>; else goto <D.29088>;
  <D.29090>:
  D.29091 = cfg->vreg_is_mp;
  D.29082 = (long unsigned int) vreg;
  D.29083 = D.29082 * 4;
  D.29092 = D.29091 + D.29083;
  D.29093 = *D.29092;
  if (D.29093 != 0) goto <D.29094>; else goto <D.29088>;
  <D.29094>:
  D.29087 = alloc_ireg_mp (cfg);
  return D.29087;
  <D.29088>:
  D.29087 = alloc_ireg (cfg);
  return D.29087;
}


mono_type_to_regmove (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.29096;
  long unsigned int D.29097;
  guint D.29100;
  unsigned char D.29101;
  int D.29102;
  struct MonoClass * D.29103;
  long unsigned int D.29104;
  long unsigned int D.29105;
  struct MonoGenericClass * D.29110;
  struct MonoClass * D.29111;
  struct MonoGenericSharingContext * D.29112;
  _Bool D.29113;
  long int D.29114;
  long int D.29115;
  int D.29118;
  void handle_enum = <<< error >>>;

  D.29096 = BIT_FIELD_REF <*type, 64, 64>;
  D.29097 = D.29096 & 1073741824;
  if (D.29097 != 0) goto <D.29098>; else goto <D.29099>;
  <D.29098>:
  D.29100 = 424;
  return D.29100;
  <D.29099>:
  type = mini_replace_type (type);
  handle_enum:
  D.29101 = type->type;
  D.29102 = (int) D.29101;
  switch (D.29102) <default: <D.24957>, case 2: <D.24933>, case 3: <D.24936>, case 4: <D.24931>, case 5: <D.24932>, case 6: <D.24934>, case 7: <D.24935>, case 8: <D.24937>, case 9: <D.24938>, case 10: <D.24948>, case 11: <D.24949>, case 12: <D.24950>, case 13: <D.24951>, case 14: <D.24944>, case 15: <D.24941>, case 17: <D.24952>, case 18: <D.24943>, case 19: <D.24955>, case 20: <D.24947>, case 21: <D.24954>, case 22: <D.24953>, case 24: <D.24939>, case 25: <D.24940>, case 27: <D.24942>, case 28: <D.24945>, case 29: <D.24946>, case 30: <D.24956>>
  <D.24931>:
  <D.24932>:
  <D.24933>:
  D.29100 = 424;
  return D.29100;
  <D.24934>:
  <D.24935>:
  <D.24936>:
  D.29100 = 424;
  return D.29100;
  <D.24937>:
  <D.24938>:
  D.29100 = 424;
  return D.29100;
  <D.24939>:
  <D.24940>:
  <D.24941>:
  <D.24942>:
  D.29100 = 424;
  return D.29100;
  <D.24943>:
  <D.24944>:
  <D.24945>:
  <D.24946>:
  <D.24947>:
  D.29100 = 424;
  return D.29100;
  <D.24948>:
  <D.24949>:
  D.29100 = 424;
  return D.29100;
  <D.24950>:
  D.29100 = 426;
  return D.29100;
  <D.24951>:
  D.29100 = 426;
  return D.29100;
  <D.24952>:
  D.29103 = type->data.klass;
  D.29104 = BIT_FIELD_REF <*D.29103, 64, 256>;
  D.29105 = D.29104 & 16;
  if (D.29105 != 0) goto <D.29106>; else goto <D.29107>;
  <D.29106>:
  D.29103 = type->data.klass;
  type = mono_class_enum_basetype (D.29103);
  goto handle_enum;
  <D.29107>:
  if (0 != 0) goto <D.29108>; else goto <D.29109>;
  <D.29108>:
  D.29100 = 800;
  return D.29100;
  <D.29109>:
  D.29100 = 427;
  return D.29100;
  <D.24953>:
  D.29100 = 427;
  return D.29100;
  <D.24954>:
  D.29110 = type->data.generic_class;
  D.29111 = D.29110->container_class;
  type = &D.29111->byval_arg;
  goto handle_enum;
  <D.24955>:
  <D.24956>:
  D.29112 = cfg->generic_sharing_context;
  D.29113 = D.29112 == 0B;
  D.29114 = (long int) D.29113;
  D.29115 = __builtin_expect (D.29114, 0);
  if (D.29115 != 0) goto <D.29116>; else goto <D.29117>;
  <D.29116>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 324, "cfg->generic_sharing_context");
  <D.29117>:
  D.29118 = mini_type_var_is_vt (cfg, type);
  if (D.29118 != 0) goto <D.29119>; else goto <D.29120>;
  <D.29119>:
  D.29100 = 427;
  return D.29100;
  <D.29120>:
  D.29100 = 424;
  return D.29100;
  <D.24957>:
  D.29101 = type->type;
  D.29102 = (int) D.29101;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_regstore", D.29102);
  <D.24958>:
  goto <D.24958>;
  D.29100 = 4294967295;
  return D.29100;
}


mono_print_bb (struct MonoBasicBlock * bb, const char * msg)
{
  int D.29122;
  struct MonoBasicBlock * * D.29123;
  long unsigned int D.29124;
  long unsigned int D.29125;
  struct MonoBasicBlock * * D.29126;
  struct MonoBasicBlock * D.29127;
  int D.29128;
  int D.29129;
  short int D.29130;
  int D.29131;
  struct MonoBasicBlock * * D.29132;
  struct MonoBasicBlock * * D.29133;
  struct MonoBasicBlock * D.29134;
  int D.29135;
  int D.29136;
  short int D.29137;
  int D.29138;
  int i;
  struct MonoInst * tree;

  D.29122 = bb->block_num;
  printf ("\n%s %d: [IN: ", msg, D.29122);
  i = 0;
  goto <D.24966>;
  <D.24965>:
  D.29123 = bb->in_bb;
  D.29124 = (long unsigned int) i;
  D.29125 = D.29124 * 8;
  D.29126 = D.29123 + D.29125;
  D.29127 = *D.29126;
  D.29128 = D.29127->block_num;
  D.29123 = bb->in_bb;
  D.29124 = (long unsigned int) i;
  D.29125 = D.29124 * 8;
  D.29126 = D.29123 + D.29125;
  D.29127 = *D.29126;
  D.29129 = D.29127->dfn;
  printf (" BB%d(%d)", D.29128, D.29129);
  i = i + 1;
  <D.24966>:
  D.29130 = bb->in_count;
  D.29131 = (int) D.29130;
  if (D.29131 > i) goto <D.24965>; else goto <D.24967>;
  <D.24967>:
  printf (", OUT: ");
  i = 0;
  goto <D.24969>;
  <D.24968>:
  D.29132 = bb->out_bb;
  D.29124 = (long unsigned int) i;
  D.29125 = D.29124 * 8;
  D.29133 = D.29132 + D.29125;
  D.29134 = *D.29133;
  D.29135 = D.29134->block_num;
  D.29132 = bb->out_bb;
  D.29124 = (long unsigned int) i;
  D.29125 = D.29124 * 8;
  D.29133 = D.29132 + D.29125;
  D.29134 = *D.29133;
  D.29136 = D.29134->dfn;
  printf (" BB%d(%d)", D.29135, D.29136);
  i = i + 1;
  <D.24969>:
  D.29137 = bb->out_count;
  D.29138 = (int) D.29137;
  if (D.29138 > i) goto <D.24968>; else goto <D.24970>;
  <D.24970>:
  printf (" ]\n");
  tree = bb->code;
  goto <D.24972>;
  <D.24971>:
  mono_print_ins_index (-1, tree);
  tree = tree->next;
  <D.24972>:
  if (tree != 0B) goto <D.24971>; else goto <D.24973>;
  <D.24973>:
}


printf (const char * restrict __fmt)
{
  int D.29139;

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


mono_create_helper_signatures ()
{
  struct MonoMethodSignature * helper_sig_domain_get.0;
  struct MonoMethodSignature * helper_sig_class_init_trampoline.1;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline.2;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline_llvm.3;
  struct MonoMethodSignature * helper_sig_rgctx_lazy_fetch_trampoline.4;
  struct MonoMethodSignature * helper_sig_monitor_enter_exit_trampoline.5;
  struct MonoMethodSignature * helper_sig_monitor_enter_exit_trampoline_llvm.6;

  helper_sig_domain_get.0 = mono_create_icall_signature ("ptr");
  helper_sig_domain_get = helper_sig_domain_get.0;
  helper_sig_class_init_trampoline.1 = mono_create_icall_signature ("void");
  helper_sig_class_init_trampoline = helper_sig_class_init_trampoline.1;
  helper_sig_generic_class_init_trampoline.2 = mono_create_icall_signature ("void");
  helper_sig_generic_class_init_trampoline = helper_sig_generic_class_init_trampoline.2;
  helper_sig_generic_class_init_trampoline_llvm.3 = mono_create_icall_signature ("void ptr");
  helper_sig_generic_class_init_trampoline_llvm = helper_sig_generic_class_init_trampoline_llvm.3;
  helper_sig_rgctx_lazy_fetch_trampoline.4 = mono_create_icall_signature ("ptr ptr");
  helper_sig_rgctx_lazy_fetch_trampoline = helper_sig_rgctx_lazy_fetch_trampoline.4;
  helper_sig_monitor_enter_exit_trampoline.5 = mono_create_icall_signature ("void");
  helper_sig_monitor_enter_exit_trampoline = helper_sig_monitor_enter_exit_trampoline.5;
  helper_sig_monitor_enter_exit_trampoline_llvm.6 = mono_create_icall_signature ("void object");
  helper_sig_monitor_enter_exit_trampoline_llvm = helper_sig_monitor_enter_exit_trampoline_llvm.6;
}


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.29148;
  long unsigned int D.29149;
  long unsigned int D.29150;
  struct MonoBasicBlock * * D.29151;
  struct MonoBasicBlock * D.29152;
  short int D.29155;
  int D.29156;
  struct MonoMemPool * D.29159;
  int D.29160;
  long unsigned int D.29161;
  unsigned int D.29162;
  unsigned int D.29163;
  struct MonoBasicBlock * * D.29164;
  short int D.29165;
  unsigned short D.29166;
  unsigned short D.29167;
  short int D.29168;
  struct MonoBasicBlock * * D.29169;
  struct MonoBasicBlock * * D.29170;
  struct MonoBasicBlock * D.29171;
  short int D.29174;
  int D.29175;
  int D.29178;
  long unsigned int D.29179;
  unsigned int D.29180;
  unsigned int D.29181;
  short int D.29182;
  unsigned short D.29183;
  unsigned short D.29184;
  short int D.29185;
  struct MonoBasicBlock * * newa;
  int i;
  int found;

  found = 0;
  i = 0;
  goto <D.24987>;
  <D.24986>:
  D.29148 = from->out_bb;
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29151 = D.29148 + D.29150;
  D.29152 = *D.29151;
  if (D.29152 == to) goto <D.29153>; else goto <D.29154>;
  <D.29153>:
  found = 1;
  goto <D.24985>;
  <D.29154>:
  i = i + 1;
  <D.24987>:
  D.29155 = from->out_count;
  D.29156 = (int) D.29155;
  if (D.29156 > i) goto <D.24986>; else goto <D.24985>;
  <D.24985>:
  if (found == 0) goto <D.29157>; else goto <D.29158>;
  <D.29157>:
  D.29159 = cfg->mempool;
  D.29155 = from->out_count;
  D.29156 = (int) D.29155;
  D.29160 = D.29156 + 1;
  D.29161 = (long unsigned int) D.29160;
  D.29162 = (unsigned int) D.29161;
  D.29163 = D.29162 * 8;
  newa = mono_mempool_alloc (D.29159, D.29163);
  i = 0;
  goto <D.24989>;
  <D.24988>:
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29164 = newa + D.29150;
  D.29148 = from->out_bb;
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29151 = D.29148 + D.29150;
  D.29152 = *D.29151;
  *D.29164 = D.29152;
  i = i + 1;
  <D.24989>:
  D.29155 = from->out_count;
  D.29156 = (int) D.29155;
  if (D.29156 > i) goto <D.24988>; else goto <D.24990>;
  <D.24990>:
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29164 = newa + D.29150;
  *D.29164 = to;
  D.29155 = from->out_count;
  D.29165 = D.29155;
  D.29166 = (unsigned short) D.29165;
  D.29167 = D.29166 + 1;
  D.29168 = (short int) D.29167;
  from->out_count = D.29168;
  from->out_bb = newa;
  <D.29158>:
  found = 0;
  i = 0;
  goto <D.24993>;
  <D.24992>:
  D.29169 = to->in_bb;
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29170 = D.29169 + D.29150;
  D.29171 = *D.29170;
  if (D.29171 == from) goto <D.29172>; else goto <D.29173>;
  <D.29172>:
  found = 1;
  goto <D.24991>;
  <D.29173>:
  i = i + 1;
  <D.24993>:
  D.29174 = to->in_count;
  D.29175 = (int) D.29174;
  if (D.29175 > i) goto <D.24992>; else goto <D.24991>;
  <D.24991>:
  if (found == 0) goto <D.29176>; else goto <D.29177>;
  <D.29176>:
  D.29159 = cfg->mempool;
  D.29174 = to->in_count;
  D.29175 = (int) D.29174;
  D.29178 = D.29175 + 1;
  D.29179 = (long unsigned int) D.29178;
  D.29180 = (unsigned int) D.29179;
  D.29181 = D.29180 * 8;
  newa = mono_mempool_alloc (D.29159, D.29181);
  i = 0;
  goto <D.24995>;
  <D.24994>:
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29164 = newa + D.29150;
  D.29169 = to->in_bb;
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29170 = D.29169 + D.29150;
  D.29171 = *D.29170;
  *D.29164 = D.29171;
  i = i + 1;
  <D.24995>:
  D.29174 = to->in_count;
  D.29175 = (int) D.29174;
  if (D.29175 > i) goto <D.24994>; else goto <D.24996>;
  <D.24996>:
  D.29149 = (long unsigned int) i;
  D.29150 = D.29149 * 8;
  D.29164 = newa + D.29150;
  *D.29164 = from;
  D.29174 = to->in_count;
  D.29182 = D.29174;
  D.29183 = (unsigned short) D.29182;
  D.29184 = D.29183 + 1;
  D.29185 = (short int) D.29184;
  to->in_count = D.29185;
  to->in_bb = newa;
  <D.29177>:
}


mono_find_exvar_for_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.29186;
  struct GHashTable * D.29187;
  long int D.29188;
  const void * D.29189;

  D.29187 = cfg->exvars;
  D.29188 = (long int) offset;
  D.29189 = (const void *) D.29188;
  D.29186 = monoeg_g_hash_table_lookup (D.29187, D.29189);
  return D.29186;
}


type_to_eval_stack_type (struct MonoCompile * cfg, struct MonoType * type, struct MonoInst * inst)
{
  long unsigned int D.29191;
  long unsigned int D.29192;
  unsigned char D.29195;
  int D.29196;
  struct MonoClass * D.29197;
  long unsigned int D.29198;
  long unsigned int D.29199;
  struct MonoClass * D.29202;
  struct MonoGenericClass * D.29203;
  struct MonoClass * D.29204;
  struct MonoGenericSharingContext * D.29205;
  _Bool D.29206;
  long int D.29207;
  long int D.29208;
  int D.29211;
  int D.29214;
  _Bool D.29215;
  long int D.29216;
  long int D.29217;
  struct MonoClass * klass;
  void handle_enum = <<< error >>>;

  type = mini_replace_type (type);
  klass = mono_class_from_mono_type (type);
  inst->klass = klass;
  D.29191 = BIT_FIELD_REF <*type, 64, 64>;
  D.29192 = D.29191 & 1073741824;
  if (D.29192 != 0) goto <D.29193>; else goto <D.29194>;
  <D.29193>:
  inst->type = 5;
  return;
  <D.29194>:
  handle_enum:
  D.29195 = type->type;
  D.29196 = (int) D.29195;
  switch (D.29196) <default: <D.25073>, case 1: <D.25046>, case 2: <D.25049>, case 3: <D.25052>, case 4: <D.25047>, case 5: <D.25048>, case 6: <D.25050>, case 7: <D.25051>, case 8: <D.25053>, case 9: <D.25054>, case 10: <D.25064>, case 11: <D.25065>, case 12: <D.25066>, case 13: <D.25067>, case 14: <D.25060>, case 15: <D.25057>, case 17: <D.25068>, case 18: <D.25059>, case 19: <D.25071>, case 20: <D.25063>, case 21: <D.25070>, case 22: <D.25069>, case 24: <D.25055>, case 25: <D.25056>, case 27: <D.25058>, case 28: <D.25061>, case 29: <D.25062>, case 30: <D.25072>>
  <D.25046>:
  inst->type = 0;
  return;
  <D.25047>:
  <D.25048>:
  <D.25049>:
  <D.25050>:
  <D.25051>:
  <D.25052>:
  <D.25053>:
  <D.25054>:
  inst->type = 1;
  return;
  <D.25055>:
  <D.25056>:
  <D.25057>:
  <D.25058>:
  inst->type = 3;
  return;
  <D.25059>:
  <D.25060>:
  <D.25061>:
  <D.25062>:
  <D.25063>:
  inst->type = 6;
  return;
  <D.25064>:
  <D.25065>:
  inst->type = 2;
  return;
  <D.25066>:
  <D.25067>:
  inst->type = 4;
  return;
  <D.25068>:
  D.29197 = type->data.klass;
  D.29198 = BIT_FIELD_REF <*D.29197, 64, 256>;
  D.29199 = D.29198 & 16;
  if (D.29199 != 0) goto <D.29200>; else goto <D.29201>;
  <D.29200>:
  D.29197 = type->data.klass;
  type = mono_class_enum_basetype (D.29197);
  goto handle_enum;
  <D.29201>:
  inst->klass = klass;
  inst->type = 7;
  return;
  <D.25069>:
  D.29202 = mono_defaults.typed_reference_class;
  inst->klass = D.29202;
  inst->type = 7;
  return;
  <D.25070>:
  D.29203 = type->data.generic_class;
  D.29204 = D.29203->container_class;
  type = &D.29204->byval_arg;
  goto handle_enum;
  <D.25071>:
  <D.25072>:
  D.29205 = cfg->generic_sharing_context;
  D.29206 = D.29205 == 0B;
  D.29207 = (long int) D.29206;
  D.29208 = __builtin_expect (D.29207, 0);
  if (D.29208 != 0) goto <D.29209>; else goto <D.29210>;
  <D.29209>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 717, "cfg->generic_sharing_context");
  <D.29210>:
  D.29211 = mini_is_gsharedvt_type (cfg, type);
  if (D.29211 != 0) goto <D.29212>; else goto <D.29213>;
  <D.29212>:
  D.29214 = cfg->gsharedvt;
  D.29215 = D.29214 == 0;
  D.29216 = (long int) D.29215;
  D.29217 = __builtin_expect (D.29216, 0);
  if (D.29217 != 0) goto <D.29218>; else goto <D.29219>;
  <D.29218>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 719, "cfg->gsharedvt");
  <D.29219>:
  inst->type = 7;
  goto <D.29220>;
  <D.29213>:
  inst->type = 6;
  <D.29220>:
  return;
  <D.25073>:
  D.29195 = type->type;
  D.29196 = (int) D.29195;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in eval stack type", D.29196);
  <D.25074>:
  goto <D.25074>;
}


mono_get_got_var (struct MonoCompile * cfg)
{
  long unsigned int D.29222;
  long unsigned int D.29223;
  struct MonoInst * D.29226;
  struct MonoInst * D.29227;
  struct MonoClass * D.29230;
  struct MonoType * D.29231;
  struct MonoInst * D.29232;

  D.29222 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29223 = D.29222 & 274877906944;
  if (D.29223 == 0) goto <D.29224>; else goto <D.29225>;
  <D.29224>:
  D.29226 = 0B;
  return D.29226;
  <D.29225>:
  D.29227 = cfg->got_var;
  if (D.29227 == 0B) goto <D.29228>; else goto <D.29229>;
  <D.29228>:
  D.29230 = mono_defaults.int_class;
  D.29231 = &D.29230->byval_arg;
  D.29232 = mono_compile_create_var (cfg, D.29231, 329);
  cfg->got_var = D.29232;
  <D.29229>:
  D.29226 = cfg->got_var;
  return D.29226;
}


mini_emit_memcpy (struct MonoCompile * cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
{
  _Bool D.29236;
  long int D.29237;
  long int D.29238;
  unsigned int D.29243;
  struct MonoMemPool * D.29244;
  long int D.29245;
  struct MonoInst * D.29246;
  int D.29247;
  int D.29248;
  const unsigned char * D.29249;
  long int D.29250;
  struct MonoBasicBlock * D.29251;
  struct MonoInst * D.29252;
  long int D.29256;
  struct MonoInst * D.29257;
  int D.29258;
  int D.29259;
  long int D.29260;
  unsigned int D.29266;
  long int D.29267;
  struct MonoInst * D.29268;
  int D.29269;
  int D.29270;
  long int D.29274;
  struct MonoInst * D.29275;
  int D.29276;
  int D.29277;
  unsigned int D.29281;
  long int D.29282;
  struct MonoInst * D.29283;
  int D.29284;
  int D.29285;
  long int D.29289;
  struct MonoInst * D.29290;
  int D.29291;
  int D.29292;
  unsigned int D.29296;
  long int D.29297;
  struct MonoInst * D.29298;
  int D.29299;
  int D.29300;
  long int D.29304;
  struct MonoInst * D.29305;
  int D.29306;
  int D.29307;
  unsigned int D.29311;
  long int D.29312;
  struct MonoInst * D.29313;
  int D.29314;
  int D.29315;
  long int D.29319;
  struct MonoInst * D.29320;
  int D.29321;
  int D.29322;
  int cur_reg;

  if (align == 0) goto <D.29234>; else goto <D.29235>;
  <D.29234>:
  align = 4;
  <D.29235>:
  D.29236 = size > 9999;
  D.29237 = (long int) D.29236;
  D.29238 = __builtin_expect (D.29237, 0);
  if (D.29238 != 0) goto <D.29239>; else goto <D.29240>;
  <D.29239>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1826, "size < 10000");
  <D.29240>:
  if (align <= 3) goto <D.29241>; else goto <D.29242>;
  <D.29241>:
  goto <D.25590>;
  <D.25589>:
  D.29243 = alloc_preg (cfg);
  cur_reg = (int) D.29243;
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29245 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29245;
    inst->prev = 0B;
    D.29246 = inst->prev;
    inst->next = D.29246;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29247 = inst->sreg3;
    inst->sreg2 = D.29247;
    D.29248 = inst->sreg2;
    inst->sreg1 = D.29248;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.29250 = (long int) soffset;
    inst->data.op[0].const_val = D.29250;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29253>; else goto <D.29254>;
    <D.29253>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29255>;
    <D.29254>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29255>:
  }
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29256 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29256;
    inst->prev = 0B;
    D.29257 = inst->prev;
    inst->next = D.29257;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29258 = inst->sreg3;
    inst->sreg2 = D.29258;
    D.29259 = inst->sreg2;
    inst->sreg1 = D.29259;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.29260 = (long int) doffset;
    inst->data.op[0].const_val = D.29260;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29261>; else goto <D.29262>;
    <D.29261>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29263>;
    <D.29262>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29263>:
  }
  doffset = doffset + 1;
  soffset = soffset + 1;
  size = size + -1;
  <D.25590>:
  if (size > 0) goto <D.25589>; else goto <D.25591>;
  <D.25591>:
  <D.29242>:
  if (1 != 0) goto <D.29264>; else goto <D.29265>;
  <D.29264>:
  goto <D.25595>;
  <D.25594>:
  D.29266 = alloc_preg (cfg);
  cur_reg = (int) D.29266;
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29267 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29267;
    inst->prev = 0B;
    D.29268 = inst->prev;
    inst->next = D.29268;
    inst->opcode = 395;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29269 = inst->sreg3;
    inst->sreg2 = D.29269;
    D.29270 = inst->sreg2;
    inst->sreg1 = D.29270;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.29250 = (long int) soffset;
    inst->data.op[0].const_val = D.29250;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29271>; else goto <D.29272>;
    <D.29271>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29273>;
    <D.29272>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29273>:
  }
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29274 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29274;
    inst->prev = 0B;
    D.29275 = inst->prev;
    inst->next = D.29275;
    inst->opcode = 378;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29276 = inst->sreg3;
    inst->sreg2 = D.29276;
    D.29277 = inst->sreg2;
    inst->sreg1 = D.29277;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.29260 = (long int) doffset;
    inst->data.op[0].const_val = D.29260;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29278>; else goto <D.29279>;
    <D.29278>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29280>;
    <D.29279>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29280>:
  }
  doffset = doffset + 8;
  soffset = soffset + 8;
  size = size + -8;
  <D.25595>:
  if (size > 7) goto <D.25594>; else goto <D.25596>;
  <D.25596>:
  <D.29265>:
  goto <D.25600>;
  <D.25599>:
  D.29281 = alloc_preg (cfg);
  cur_reg = (int) D.29281;
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29282 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29282;
    inst->prev = 0B;
    D.29283 = inst->prev;
    inst->next = D.29283;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29284 = inst->sreg3;
    inst->sreg2 = D.29284;
    D.29285 = inst->sreg2;
    inst->sreg1 = D.29285;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.29250 = (long int) soffset;
    inst->data.op[0].const_val = D.29250;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29286>; else goto <D.29287>;
    <D.29286>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29288>;
    <D.29287>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29288>:
  }
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29289 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29289;
    inst->prev = 0B;
    D.29290 = inst->prev;
    inst->next = D.29290;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29291 = inst->sreg3;
    inst->sreg2 = D.29291;
    D.29292 = inst->sreg2;
    inst->sreg1 = D.29292;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.29260 = (long int) doffset;
    inst->data.op[0].const_val = D.29260;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29293>; else goto <D.29294>;
    <D.29293>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29295>;
    <D.29294>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29295>:
  }
  doffset = doffset + 4;
  soffset = soffset + 4;
  size = size + -4;
  <D.25600>:
  if (size > 3) goto <D.25599>; else goto <D.25601>;
  <D.25601>:
  goto <D.25605>;
  <D.25604>:
  D.29296 = alloc_preg (cfg);
  cur_reg = (int) D.29296;
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29297 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29297;
    inst->prev = 0B;
    D.29298 = inst->prev;
    inst->next = D.29298;
    inst->opcode = 391;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29299 = inst->sreg3;
    inst->sreg2 = D.29299;
    D.29300 = inst->sreg2;
    inst->sreg1 = D.29300;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.29250 = (long int) soffset;
    inst->data.op[0].const_val = D.29250;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29301>; else goto <D.29302>;
    <D.29301>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29303>;
    <D.29302>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29303>:
  }
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29304 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29304;
    inst->prev = 0B;
    D.29305 = inst->prev;
    inst->next = D.29305;
    inst->opcode = 376;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29306 = inst->sreg3;
    inst->sreg2 = D.29306;
    D.29307 = inst->sreg2;
    inst->sreg1 = D.29307;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.29260 = (long int) doffset;
    inst->data.op[0].const_val = D.29260;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29308>; else goto <D.29309>;
    <D.29308>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29310>;
    <D.29309>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29310>:
  }
  doffset = doffset + 2;
  soffset = soffset + 2;
  size = size + -2;
  <D.25605>:
  if (size > 1) goto <D.25604>; else goto <D.25606>;
  <D.25606>:
  goto <D.25610>;
  <D.25609>:
  D.29311 = alloc_preg (cfg);
  cur_reg = (int) D.29311;
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29312 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29312;
    inst->prev = 0B;
    D.29313 = inst->prev;
    inst->next = D.29313;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29314 = inst->sreg3;
    inst->sreg2 = D.29314;
    D.29315 = inst->sreg2;
    inst->sreg1 = D.29315;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.29250 = (long int) soffset;
    inst->data.op[0].const_val = D.29250;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29316>; else goto <D.29317>;
    <D.29316>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29318>;
    <D.29317>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29318>:
  }
  {
    struct MonoInst * inst;

    D.29244 = cfg->mempool;
    inst = mono_mempool_alloc (D.29244, 80);
    inst->data.op[1].const_val = 0;
    D.29319 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29319;
    inst->prev = 0B;
    D.29320 = inst->prev;
    inst->next = D.29320;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29321 = inst->sreg3;
    inst->sreg2 = D.29321;
    D.29322 = inst->sreg2;
    inst->sreg1 = D.29322;
    D.29249 = cfg->ip;
    inst->cil_code = D.29249;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.29260 = (long int) doffset;
    inst->data.op[0].const_val = D.29260;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    if (D.29252 != 0B) goto <D.29323>; else goto <D.29324>;
    <D.29323>:
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    D.29252->next = inst;
    D.29251 = cfg->cbb;
    D.29252 = D.29251->last_ins;
    inst->prev = D.29252;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    goto <D.29325>;
    <D.29324>:
    D.29251 = cfg->cbb;
    D.29251 = cfg->cbb;
    D.29251->last_ins = inst;
    D.29252 = D.29251->last_ins;
    D.29251->code = D.29252;
    <D.29325>:
  }
  doffset = doffset + 1;
  soffset = soffset + 1;
  size = size + -1;
  <D.25610>:
  if (size > 0) goto <D.25609>; else goto <D.25611>;
  <D.25611>:
}


mono_emit_method_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoInst * * args, struct MonoInst * this)
{
  struct MonoInst * D.29326;
  struct MonoMethodSignature * D.29327;

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


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.29329;
  unsigned int D.29334;
  struct MonoMemPool * D.29335;
  long int D.29336;
  struct MonoInst * D.29337;
  int D.29338;
  int D.29339;
  const unsigned char * D.29340;
  int D.29341;
  struct MonoBasicBlock * D.29342;
  struct MonoInst * D.29343;
  long unsigned int D.29347;
  long unsigned int D.29348;
  struct MonoClass * D.29351;
  struct MonoType * D.29352;
  int iftmp.7;
  long unsigned int D.29359;
  long unsigned int D.29360;
  struct MonoClass * D.29362;
  long unsigned int D.29363;
  long unsigned int D.29364;
  struct MonoClass * D.29366;
  short unsigned int D.29367;
  int D.29368;
  int D.29369;
  struct MonoMethod * D.29371;
  struct MonoMethodSignature * D.29372;
  long unsigned int D.29373;
  long unsigned int D.29374;
  short unsigned int D.29376;
  int D.29378;
  struct MonoInst * * D.29379;
  struct MonoInst * D.29380;
  int D.29381;
  struct MonoGenericSharingContext * D.29387;
  _Bool D.29388;
  long int D.29389;
  long int D.29390;
  struct MonoInst * D.29393;
  int iftmp.8;
  unsigned int D.29399;
  unsigned int D.29400;
  _Bool D.29401;
  int D.29402;
  struct MonoMethod * D.29405;
  unsigned char D.29407;
  unsigned char D.29408;
  unsigned char D.29409;
  <unnamed-unsigned:1> D.29410;
  struct MonoClass * D.29413;
  struct MonoClass * D.29414;
  int D.25888;
  int iftmp.9;
  int D.25887;
  const char[7] * D.29420;
  unsigned char D.29421;
  int D.29422;
  unsigned char D.29423;
  int D.29424;
  const unsigned char * D.29429;
  unsigned char D.29430;
  int D.29431;
  const unsigned char * D.29432;
  unsigned char D.29433;
  int D.29434;
  const unsigned char * D.29439;
  unsigned char D.29440;
  int D.29441;
  const unsigned char * D.29442;
  unsigned char D.29443;
  int D.29444;
  const unsigned char * D.29449;
  unsigned char D.29450;
  int D.29451;
  const unsigned char * D.29452;
  unsigned char D.29453;
  int D.29454;
  const char * D.29456;
  long unsigned int D.29459;
  long unsigned int D.29460;
  long int D.29463;
  struct MonoInst * D.29464;
  int D.29465;
  int D.29466;
  long int D.29470;
  struct MonoInst * D.29471;
  int D.29472;
  int D.29473;
  long int D.29481;
  struct MonoInst * D.29482;
  int D.29483;
  int D.29484;
  struct MonoInst * D.29485;
  int D.29486;
  long unsigned int D.29496;
  long unsigned int D.29497;
  int D.29500;
  unsigned int D.29503;
  long unsigned int D.29504;
  struct MonoMethod * D.29509;
  unsigned int D.29512;
  unsigned int D.29513;
  long int D.29518;
  struct MonoInst * D.29519;
  int D.29520;
  int D.29521;
  long int D.29525;
  struct MonoInst * D.29526;
  int D.29527;
  int D.29528;
  long int D.29534;
  struct MonoInst * D.29535;
  int D.29536;
  int D.29537;
  long int D.29541;
  struct MonoInst * D.29542;
  int D.29543;
  int D.29544;
  short unsigned int D.29548;
  int D.29549;
  int D.29550;
  short unsigned int D.29551;
  long int D.29562;
  struct MonoInst * D.29563;
  int D.29564;
  int D.29565;
  long int D.29569;
  struct MonoInst * D.29570;
  int D.29571;
  int D.29572;
  long int D.29578;
  struct MonoInst * D.29579;
  int D.29580;
  int D.29581;
  long int D.29585;
  struct MonoInst * D.29586;
  int D.29587;
  int D.29588;
  int D.29592;
  short unsigned int D.29593;
  unsigned int D.29594;
  int D.29595;
  long int D.29600;
  struct MonoInst * D.29601;
  int D.29602;
  int D.29603;
  long int D.29607;
  struct MonoInst * D.29608;
  int D.29609;
  int D.29610;
  long int D.29615;
  struct MonoInst * D.29616;
  int D.29617;
  int D.29618;
  unsigned char D.29619;
  int mono_use_imt.10;
  struct MonoMethod * D.29628;
  int imt_slot.11;
  int D.29630;
  unsigned int D.29633;
  int D.29634;
  int D.29636;
  int D.29637;
  unsigned int D.29638;
  unsigned int D.29639;
  struct MonoMethodSignature * D.29642;
  short unsigned int D.29643;
  _Bool D.29644;
  long int D.29645;
  long int D.29646;
  long int D.29649;
  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.29329 = this != 0B;
  virtual = (gboolean) D.29329;
  enable_for_aot = 1;
  rgctx_reg = 0;
  if (sig == 0B) goto <D.29330>; else goto <D.29331>;
  <D.29330>:
  sig = mono_method_signature (method);
  <D.29331>:
  if (rgctx_arg != 0B) goto <D.29332>; else goto <D.29333>;
  <D.29332>:
  D.29334 = mono_alloc_preg (cfg);
  rgctx_reg = (int) D.29334;
  {
    struct MonoInst * inst;

    D.29335 = cfg->mempool;
    inst = mono_mempool_alloc (D.29335, 80);
    inst->data.op[1].const_val = 0;
    D.29336 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29336;
    inst->prev = 0B;
    D.29337 = inst->prev;
    inst->next = D.29337;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29338 = inst->sreg3;
    inst->sreg2 = D.29338;
    D.29339 = inst->sreg2;
    inst->sreg1 = D.29339;
    D.29340 = cfg->ip;
    inst->cil_code = D.29340;
    inst->dreg = rgctx_reg;
    D.29341 = rgctx_arg->dreg;
    inst->sreg1 = D.29341;
    D.29342 = cfg->cbb;
    D.29343 = D.29342->last_ins;
    if (D.29343 != 0B) goto <D.29344>; else goto <D.29345>;
    <D.29344>:
    D.29342 = cfg->cbb;
    D.29343 = D.29342->last_ins;
    D.29343->next = inst;
    D.29342 = cfg->cbb;
    D.29343 = D.29342->last_ins;
    inst->prev = D.29343;
    D.29342 = cfg->cbb;
    D.29342->last_ins = inst;
    goto <D.29346>;
    <D.29345>:
    D.29342 = cfg->cbb;
    D.29342 = cfg->cbb;
    D.29342->last_ins = inst;
    D.29343 = D.29342->last_ins;
    D.29342->code = D.29343;
    <D.29346>:
  }
  <D.29333>:
  D.29347 = BIT_FIELD_REF <*method, 64, 256>;
  D.29348 = D.29347 & 128;
  if (D.29348 != 0) goto <D.29349>; else goto <D.29350>;
  <D.29349>:
  {
    struct MonoMethodSignature * ctor_sig;

    D.29335 = cfg->mempool;
    ctor_sig = mono_metadata_signature_dup_mempool (D.29335, sig);
    D.29351 = mono_defaults.string_class;
    D.29352 = &D.29351->byval_arg;
    ctor_sig->ret = D.29352;
    sig = ctor_sig;
  }
  <D.29350>:
  context_used = mini_method_check_context_used (cfg, method);
  if (this != 0B) goto <D.29358>; else goto <D.29354>;
  <D.29358>:
  D.29359 = BIT_FIELD_REF <*sig, 64, 64>;
  D.29360 = D.29359 & 18014398509481984;
  if (D.29360 != 0) goto <D.29361>; else goto <D.29354>;
  <D.29361>:
  D.29362 = method->klass;
  D.29363 = BIT_FIELD_REF <*D.29362, 64, 256>;
  D.29364 = D.29363 & 4194304;
  if (D.29364 != 0) goto <D.29355>; else goto <D.29365>;
  <D.29365>:
  D.29362 = method->klass;
  D.29366 = mono_defaults.object_class;
  if (D.29362 == D.29366) goto <D.29355>; else goto <D.29354>;
  <D.29355>:
  D.29367 = method->flags;
  D.29368 = (int) D.29367;
  D.29369 = D.29368 & 64;
  if (D.29369 == 0) goto <D.29370>; else goto <D.29354>;
  <D.29370>:
  D.29371 = cfg->method;
  D.29372 = mono_method_signature (D.29371);
  D.29373 = BIT_FIELD_REF <*D.29372, 64, 64>;
  D.29374 = D.29373 & 18014398509481984;
  if (D.29374 == 0) goto <D.29356>; else goto <D.29375>;
  <D.29375>:
  D.29376 = this->opcode;
  if (D.29376 != 424) goto <D.29356>; else goto <D.29377>;
  <D.29377>:
  D.29378 = this->sreg1;
  D.29379 = cfg->args;
  D.29380 = *D.29379;
  D.29381 = D.29380->dreg;
  if (D.29378 != D.29381) goto <D.29356>; else goto <D.29382>;
  <D.29382>:
  if (context_used != 0) goto <D.29356>; else goto <D.29354>;
  <D.29356>:
  iftmp.7 = 1;
  goto <D.29357>;
  <D.29354>:
  iftmp.7 = 0;
  <D.29357>:
  might_be_remote = iftmp.7;
  if (might_be_remote != 0) goto <D.29383>; else goto <D.29384>;
  <D.29383>:
  if (context_used != 0) goto <D.29385>; else goto <D.29386>;
  <D.29385>:
  {
    struct MonoInst * addr;

    D.29387 = cfg->generic_sharing_context;
    D.29388 = D.29387 == 0B;
    D.29389 = (long int) D.29388;
    D.29390 = __builtin_expect (D.29389, 0);
    if (D.29390 != 0) goto <D.29391>; else goto <D.29392>;
    <D.29391>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2632, "cfg->generic_sharing_context");
    <D.29392>:
    addr = emit_get_rgctx_method (cfg, context_used, method, 10);
    D.29393 = mono_emit_calli (cfg, sig, args, addr, 0B, 0B);
    return D.29393;
  }
  <D.29386>:
  <D.29384>:
  D.29362 = method->klass;
  D.29366 = mono_defaults.object_class;
  if (D.29362 == D.29366) goto <D.29395>; else goto <D.29398>;
  <D.29398>:
  D.29362 = method->klass;
  D.29399 = D.29362->flags;
  D.29400 = D.29399 & 32;
  if (D.29400 != 0) goto <D.29395>; else goto <D.29396>;
  <D.29395>:
  iftmp.8 = 1;
  goto <D.29397>;
  <D.29396>:
  iftmp.8 = 0;
  <D.29397>:
  need_unbox_trampoline = iftmp.8;
  D.29401 = rgctx_arg != 0B;
  D.29402 = (int) D.29401;
  call = mono_emit_call_args (cfg, sig, args, 0, virtual, tail, D.29402, need_unbox_trampoline);
  if (might_be_remote != 0) goto <D.29403>; else goto <D.29404>;
  <D.29403>:
  D.29405 = mono_marshal_get_remoting_invoke_with_check (method);
  call->method = D.29405;
  goto <D.29406>;
  <D.29404>:
  call->method = method;
  <D.29406>:
  D.29407 = call->inst.flags;
  D.29408 = D.29407 | 1;
  call->inst.flags = D.29408;
  call->inst.data.op[0].src = this;
  D.29409 = (unsigned char) tail;
  D.29410 = (<unnamed-unsigned:1>) D.29409;
  call->tail_call = D.29410;
  if (virtual != 0) goto <D.29411>; else goto <D.29412>;
  <D.29411>:
  {
    int vtable_reg;
    int slot_reg;
    int this_reg;
    int offset;

    this_reg = this->dreg;
    D.29362 = method->klass;
    D.29413 = D.29362->parent;
    D.29414 = mono_defaults.multicastdelegate_class;
    if (D.29413 == D.29414) goto <D.29415>; else goto <D.29416>;
    <D.29415>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.29418>; else goto <D.29419>;
      <D.29418>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = method->name;
        D.29420 = "Invoke";
        D.29421 = MEM[(const unsigned char *)D.29420];
        D.29422 = (int) D.29421;
        D.29423 = *__s2;
        D.29424 = (int) D.29423;
        __result = D.29422 - D.29424;
        {
          if (__s2_len != 0) goto <D.29425>; else goto <D.29426>;
          <D.29425>:
          if (__result == 0) goto <D.29427>; else goto <D.29428>;
          <D.29427>:
          D.29429 = &MEM[(void *)"Invoke" + 1B];
          D.29430 = *D.29429;
          D.29431 = (int) D.29430;
          D.29432 = __s2 + 1;
          D.29433 = *D.29432;
          D.29434 = (int) D.29433;
          __result = D.29431 - D.29434;
          if (__s2_len > 1) goto <D.29435>; else goto <D.29436>;
          <D.29435>:
          if (__result == 0) goto <D.29437>; else goto <D.29438>;
          <D.29437>:
          D.29439 = &MEM[(void *)"Invoke" + 2B];
          D.29440 = *D.29439;
          D.29441 = (int) D.29440;
          D.29442 = __s2 + 2;
          D.29443 = *D.29442;
          D.29444 = (int) D.29443;
          __result = D.29441 - D.29444;
          if (__s2_len > 2) goto <D.29445>; else goto <D.29446>;
          <D.29445>:
          if (__result == 0) goto <D.29447>; else goto <D.29448>;
          <D.29447>:
          D.29449 = &MEM[(void *)"Invoke" + 3B];
          D.29450 = *D.29449;
          D.29451 = (int) D.29450;
          D.29452 = __s2 + 3;
          D.29453 = *D.29452;
          D.29454 = (int) D.29453;
          __result = D.29451 - D.29454;
          <D.29448>:
          <D.29446>:
          <D.29438>:
          <D.29436>:
          <D.29428>:
          <D.29426>:
        }
        D.25887 = __result;
      }
      iftmp.9 = -D.25887;
      goto <D.29455>;
      <D.29419>:
      D.29456 = method->name;
      iftmp.9 = __builtin_strcmp (D.29456, "Invoke");
      <D.29455>:
      D.25888 = iftmp.9;
    }
    if (D.25888 == 0) goto <D.29457>; else goto <D.29458>;
    <D.29457>:
    {
      struct MonoInst * dummy_use;

      D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.29460 = D.29459 & 64;
      if (D.29460 != 0) goto <D.29461>; else goto <D.29462>;
      <D.29461>:
      {
        struct MonoInst * inst;

        D.29335 = cfg->mempool;
        inst = mono_mempool_alloc (D.29335, 80);
        inst->data.op[1].const_val = 0;
        D.29463 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29463;
        inst->prev = 0B;
        D.29464 = inst->prev;
        inst->next = D.29464;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29465 = inst->sreg3;
        inst->sreg2 = D.29465;
        D.29466 = inst->sreg2;
        inst->sreg1 = D.29466;
        D.29340 = cfg->ip;
        inst->cil_code = D.29340;
        inst->dreg = -1;
        inst->sreg1 = this_reg;
        inst->data.op[1].const_val = 0;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        if (D.29343 != 0B) goto <D.29467>; else goto <D.29468>;
        <D.29467>:
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        D.29343->next = inst;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        inst->prev = D.29343;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        goto <D.29469>;
        <D.29468>:
        D.29342 = cfg->cbb;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        D.29343 = D.29342->last_ins;
        D.29342->code = D.29343;
        <D.29469>:
      }
      {
        struct MonoInst * inst;

        D.29335 = cfg->mempool;
        inst = mono_mempool_alloc (D.29335, 80);
        inst->data.op[1].const_val = 0;
        D.29470 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29470;
        inst->prev = 0B;
        D.29471 = inst->prev;
        inst->next = D.29471;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29472 = inst->sreg3;
        inst->sreg2 = D.29472;
        D.29473 = inst->sreg2;
        inst->sreg1 = D.29473;
        D.29340 = cfg->ip;
        inst->cil_code = D.29340;
        inst->data.op[1].p = "NullReferenceException";
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        if (D.29343 != 0B) goto <D.29474>; else goto <D.29475>;
        <D.29474>:
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        D.29343->next = inst;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        inst->prev = D.29343;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        goto <D.29476>;
        <D.29475>:
        D.29342 = cfg->cbb;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        D.29343 = D.29342->last_ins;
        D.29342->code = D.29343;
        <D.29476>:
      }
      goto <D.29477>;
      <D.29462>:
      <D.29477>:
      call->inst.sreg1 = this_reg;
      call->inst.data.op[0].const_val = 24;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29478>; else goto <D.29479>;
      <D.29478>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = call;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      MEM[(struct MonoInst *)call].prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = call;
      goto <D.29480>;
      <D.29479>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = call;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29480>:
      D.29335 = cfg->mempool;
      dummy_use = mono_mempool_alloc (D.29335, 80);
      dummy_use->data.op[1].const_val = 0;
      D.29481 = dummy_use->data.op[1].const_val;
      dummy_use->data.op[0].const_val = D.29481;
      dummy_use->prev = 0B;
      D.29482 = dummy_use->prev;
      dummy_use->next = D.29482;
      dummy_use->opcode = 796;
      dummy_use->flags = 0;
      dummy_use->type = 0;
      dummy_use->dreg = -1;
      dummy_use->sreg3 = -1;
      D.29483 = dummy_use->sreg3;
      dummy_use->sreg2 = D.29483;
      D.29484 = dummy_use->sreg2;
      dummy_use->sreg1 = D.29484;
      D.29340 = cfg->ip;
      dummy_use->cil_code = D.29340;
      D.29485 = *args;
      D.29486 = D.29485->dreg;
      dummy_use->sreg1 = D.29486;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29487>; else goto <D.29488>;
      <D.29487>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = dummy_use;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      dummy_use->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = dummy_use;
      goto <D.29489>;
      <D.29488>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = dummy_use;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29489>:
      D.29393 = call;
      return D.29393;
    }
    <D.29458>:
    <D.29416>:
    D.29496 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29497 = D.29496 & 274877906944;
    if (D.29497 == 0) goto <D.29490>; else goto <D.29498>;
    <D.29498>:
    if (enable_for_aot != 0) goto <D.29490>; else goto <D.29491>;
    <D.29490>:
    D.29367 = method->flags;
    D.29368 = (int) D.29367;
    D.29369 = D.29368 & 64;
    if (D.29369 == 0) goto <D.29492>; else goto <D.29499>;
    <D.29499>:
    D.29367 = method->flags;
    D.29368 = (int) D.29367;
    D.29500 = D.29368 & 32;
    if (D.29500 != 0) goto <D.29493>; else goto <D.29501>;
    <D.29501>:
    D.29362 = method->klass;
    if (D.29362 != 0B) goto <D.29502>; else goto <D.29491>;
    <D.29502>:
    D.29362 = method->klass;
    D.29399 = D.29362->flags;
    D.29503 = D.29399 & 256;
    if (D.29503 != 0) goto <D.29493>; else goto <D.29491>;
    <D.29493>:
    D.29347 = BIT_FIELD_REF <*method, 64, 256>;
    D.29504 = D.29347 & 124;
    if (D.29504 != 36) goto <D.29492>; else goto <D.29491>;
    <D.29492>:
    D.29362 = method->klass;
    D.29363 = BIT_FIELD_REF <*D.29362, 64, 256>;
    D.29364 = D.29363 & 4194304;
    if (D.29364 == 0) goto <D.29494>; else goto <D.29505>;
    <D.29505>:
    if (context_used == 0) goto <D.29494>; else goto <D.29491>;
    <D.29494>:
    D.29362 = method->klass;
    D.29363 = BIT_FIELD_REF <*D.29362, 64, 256>;
    D.29364 = D.29363 & 4194304;
    if (D.29364 != 0) goto <D.29506>; else goto <D.29508>;
    <D.29508>:
    D.29362 = method->klass;
    D.29366 = mono_defaults.object_class;
    if (D.29362 == D.29366) goto <D.29506>; else goto <D.29507>;
    <D.29506>:
    D.29509 = mono_marshal_get_remoting_invoke_with_check (method);
    call->method = D.29509;
    method = call->method;
    <D.29507>:
    D.29347 = BIT_FIELD_REF <*method, 64, 256>;
    D.29348 = D.29347 & 128;
    if (D.29348 == 0) goto <D.29510>; else goto <D.29511>;
    <D.29510>:
    D.29512 = cfg->flags;
    D.29513 = D.29512 | 128;
    cfg->flags = D.29513;
    D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.29460 = D.29459 & 64;
    if (D.29460 != 0) goto <D.29514>; else goto <D.29515>;
    <D.29514>:
    D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.29460 = D.29459 & 64;
    if (D.29460 != 0) goto <D.29516>; else goto <D.29517>;
    <D.29516>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29518 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29518;
      inst->prev = 0B;
      D.29519 = inst->prev;
      inst->next = D.29519;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29520 = inst->sreg3;
      inst->sreg2 = D.29520;
      D.29521 = inst->sreg2;
      inst->sreg1 = D.29521;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      inst->data.op[1].const_val = 0;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29522>; else goto <D.29523>;
      <D.29522>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29524>;
      <D.29523>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29524>:
    }
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29525 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29525;
      inst->prev = 0B;
      D.29526 = inst->prev;
      inst->next = D.29526;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29527 = inst->sreg3;
      inst->sreg2 = D.29527;
      D.29528 = inst->sreg2;
      inst->sreg1 = D.29528;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->data.op[1].p = "NullReferenceException";
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29529>; else goto <D.29530>;
      <D.29529>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29531>;
      <D.29530>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29531>:
    }
    goto <D.29532>;
    <D.29517>:
    <D.29532>:
    goto <D.29533>;
    <D.29515>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29534 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29534;
      inst->prev = 0B;
      D.29535 = inst->prev;
      inst->next = D.29535;
      inst->opcode = 340;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29536 = inst->sreg3;
      inst->sreg2 = D.29536;
      D.29537 = inst->sreg2;
      inst->sreg1 = D.29537;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29538>; else goto <D.29539>;
      <D.29538>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29540>;
      <D.29539>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29540>:
    }
    <D.29533>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29541 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29541;
      inst->prev = 0B;
      D.29542 = inst->prev;
      inst->next = D.29542;
      inst->opcode = 799;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29543 = inst->sreg3;
      inst->sreg2 = D.29543;
      D.29544 = inst->sreg2;
      inst->sreg1 = D.29544;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29545>; else goto <D.29546>;
      <D.29545>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29547>;
      <D.29546>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29547>:
    }
    <D.29511>:
    D.29548 = call->inst.opcode;
    D.29549 = (int) D.29548;
    D.29550 = callvirt_to_call (D.29549);
    D.29551 = (short unsigned int) D.29550;
    call->inst.opcode = D.29551;
    goto <D.29495>;
    <D.29491>:
    D.29367 = method->flags;
    D.29368 = (int) D.29367;
    D.29369 = D.29368 & 64;
    if (D.29369 != 0) goto <D.29555>; else goto <D.29552>;
    <D.29555>:
    D.29367 = method->flags;
    D.29368 = (int) D.29367;
    D.29500 = D.29368 & 32;
    if (D.29500 != 0) goto <D.29553>; else goto <D.29556>;
    <D.29556>:
    D.29362 = method->klass;
    if (D.29362 != 0B) goto <D.29557>; else goto <D.29552>;
    <D.29557>:
    D.29362 = method->klass;
    D.29399 = D.29362->flags;
    D.29503 = D.29399 & 256;
    if (D.29503 != 0) goto <D.29553>; else goto <D.29552>;
    <D.29553>:
    D.29512 = cfg->flags;
    D.29513 = D.29512 | 128;
    cfg->flags = D.29513;
    D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.29460 = D.29459 & 64;
    if (D.29460 != 0) goto <D.29558>; else goto <D.29559>;
    <D.29558>:
    D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.29460 = D.29459 & 64;
    if (D.29460 != 0) goto <D.29560>; else goto <D.29561>;
    <D.29560>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29562 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29562;
      inst->prev = 0B;
      D.29563 = inst->prev;
      inst->next = D.29563;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29564 = inst->sreg3;
      inst->sreg2 = D.29564;
      D.29565 = inst->sreg2;
      inst->sreg1 = D.29565;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      inst->data.op[1].const_val = 0;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29566>; else goto <D.29567>;
      <D.29566>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29568>;
      <D.29567>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29568>:
    }
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29569 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29569;
      inst->prev = 0B;
      D.29570 = inst->prev;
      inst->next = D.29570;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29571 = inst->sreg3;
      inst->sreg2 = D.29571;
      D.29572 = inst->sreg2;
      inst->sreg1 = D.29572;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->data.op[1].p = "NullReferenceException";
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29573>; else goto <D.29574>;
      <D.29573>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29575>;
      <D.29574>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29575>:
    }
    goto <D.29576>;
    <D.29561>:
    <D.29576>:
    goto <D.29577>;
    <D.29559>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29578 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29578;
      inst->prev = 0B;
      D.29579 = inst->prev;
      inst->next = D.29579;
      inst->opcode = 340;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29580 = inst->sreg3;
      inst->sreg2 = D.29580;
      D.29581 = inst->sreg2;
      inst->sreg1 = D.29581;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29582>; else goto <D.29583>;
      <D.29582>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29584>;
      <D.29583>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29584>:
    }
    <D.29577>:
    {
      struct MonoInst * inst;

      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29585 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29585;
      inst->prev = 0B;
      D.29586 = inst->prev;
      inst->next = D.29586;
      inst->opcode = 799;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29587 = inst->sreg3;
      inst->sreg2 = D.29587;
      D.29588 = inst->sreg2;
      inst->sreg1 = D.29588;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29589>; else goto <D.29590>;
      <D.29589>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29591>;
      <D.29590>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29591>:
    }
    D.29548 = call->inst.opcode;
    D.29549 = (int) D.29548;
    D.29592 = callvirt_to_call (D.29549);
    D.29593 = (short unsigned int) D.29592;
    call->inst.opcode = D.29593;
    goto <D.29554>;
    <D.29552>:
    D.29594 = alloc_preg (cfg);
    vtable_reg = (int) D.29594;
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.29595 = __ins_flags & 32;
      if (D.29595 != 0) goto <D.29596>; else goto <D.29597>;
      <D.29596>:
      D.29459 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.29460 = D.29459 & 64;
      if (D.29460 != 0) goto <D.29598>; else goto <D.29599>;
      <D.29598>:
      {
        struct MonoInst * inst;

        D.29335 = cfg->mempool;
        inst = mono_mempool_alloc (D.29335, 80);
        inst->data.op[1].const_val = 0;
        D.29600 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29600;
        inst->prev = 0B;
        D.29601 = inst->prev;
        inst->next = D.29601;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29602 = inst->sreg3;
        inst->sreg2 = D.29602;
        D.29603 = inst->sreg2;
        inst->sreg1 = D.29603;
        D.29340 = cfg->ip;
        inst->cil_code = D.29340;
        inst->dreg = -1;
        inst->sreg1 = this_reg;
        inst->data.op[1].const_val = 0;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        if (D.29343 != 0B) goto <D.29604>; else goto <D.29605>;
        <D.29604>:
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        D.29343->next = inst;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        inst->prev = D.29343;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        goto <D.29606>;
        <D.29605>:
        D.29342 = cfg->cbb;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        D.29343 = D.29342->last_ins;
        D.29342->code = D.29343;
        <D.29606>:
      }
      {
        struct MonoInst * inst;

        D.29335 = cfg->mempool;
        inst = mono_mempool_alloc (D.29335, 80);
        inst->data.op[1].const_val = 0;
        D.29607 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29607;
        inst->prev = 0B;
        D.29608 = inst->prev;
        inst->next = D.29608;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29609 = inst->sreg3;
        inst->sreg2 = D.29609;
        D.29610 = inst->sreg2;
        inst->sreg1 = D.29610;
        D.29340 = cfg->ip;
        inst->cil_code = D.29340;
        inst->data.op[1].p = "NullReferenceException";
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        if (D.29343 != 0B) goto <D.29611>; else goto <D.29612>;
        <D.29611>:
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        D.29343->next = inst;
        D.29342 = cfg->cbb;
        D.29343 = D.29342->last_ins;
        inst->prev = D.29343;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        goto <D.29613>;
        <D.29612>:
        D.29342 = cfg->cbb;
        D.29342 = cfg->cbb;
        D.29342->last_ins = inst;
        D.29343 = D.29342->last_ins;
        D.29342->code = D.29343;
        <D.29613>:
      }
      goto <D.29614>;
      <D.29599>:
      <D.29614>:
      <D.29597>:
      D.29335 = cfg->mempool;
      inst = mono_mempool_alloc (D.29335, 80);
      inst->data.op[1].const_val = 0;
      D.29615 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29615;
      inst->prev = 0B;
      D.29616 = inst->prev;
      inst->next = D.29616;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29617 = inst->sreg3;
      inst->sreg2 = D.29617;
      D.29618 = inst->sreg2;
      inst->sreg1 = D.29618;
      D.29340 = cfg->ip;
      inst->cil_code = D.29340;
      inst->dreg = vtable_reg;
      inst->sreg1 = this_reg;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.29619 = (unsigned char) __ins_flags;
      inst->flags = D.29619;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      if (D.29343 != 0B) goto <D.29620>; else goto <D.29621>;
      <D.29620>:
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      D.29343->next = inst;
      D.29342 = cfg->cbb;
      D.29343 = D.29342->last_ins;
      inst->prev = D.29343;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      goto <D.29622>;
      <D.29621>:
      D.29342 = cfg->cbb;
      D.29342 = cfg->cbb;
      D.29342->last_ins = inst;
      D.29343 = D.29342->last_ins;
      D.29342->code = D.29343;
      <D.29622>:
    }
    D.29362 = method->klass;
    D.29399 = D.29362->flags;
    D.29400 = D.29399 & 32;
    if (D.29400 != 0) goto <D.29623>; else goto <D.29624>;
    <D.29623>:
    slot_reg = -1;
    mono_use_imt.10 = mono_use_imt;
    if (mono_use_imt.10 != 0) goto <D.29626>; else goto <D.29627>;
    <D.29626>:
    {
      guint32 imt_slot;

      imt_slot = mono_method_get_imt_slot (method);
      D.29628 = call->method;
      emit_imt_argument (cfg, call, D.29628, imt_arg);
      slot_reg = vtable_reg;
      imt_slot.11 = (int) imt_slot;
      D.29630 = imt_slot.11 + -19;
      offset = D.29630 * 8;
    }
    <D.29627>:
    if (slot_reg == -1) goto <D.29631>; else goto <D.29632>;
    <D.29631>:
    D.29633 = alloc_preg (cfg);
    slot_reg = (int) D.29633;
    D.29362 = method->klass;
    mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, D.29362);
    D.29634 = mono_method_get_vtable_index (method);
    offset = D.29634 * 8;
    <D.29632>:
    goto <D.29635>;
    <D.29624>:
    slot_reg = vtable_reg;
    D.29636 = mono_method_get_vtable_index (method);
    D.29637 = D.29636 * 8;
    D.29638 = (unsigned int) D.29637;
    D.29639 = D.29638 + 56;
    offset = (int) D.29639;
    if (imt_arg != 0B) goto <D.29640>; else goto <D.29641>;
    <D.29640>:
    D.29642 = mono_method_signature (method);
    D.29643 = D.29642->generic_param_count;
    D.29644 = D.29643 == 0;
    D.29645 = (long int) D.29644;
    D.29646 = __builtin_expect (D.29645, 0);
    if (D.29646 != 0) goto <D.29647>; else goto <D.29648>;
    <D.29647>:
    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.29648>:
    D.29628 = call->method;
    emit_imt_argument (cfg, call, D.29628, imt_arg);
    <D.29641>:
    <D.29635>:
    call->inst.sreg1 = slot_reg;
    D.29649 = (long int) offset;
    call->inst.data.op[0].const_val = D.29649;
    call->virtual = 1;
    <D.29554>:
    <D.29495>:
  }
  <D.29412>:
  D.29342 = cfg->cbb;
  D.29343 = D.29342->last_ins;
  if (D.29343 != 0B) goto <D.29650>; else goto <D.29651>;
  <D.29650>:
  D.29342 = cfg->cbb;
  D.29343 = D.29342->last_ins;
  D.29343->next = call;
  D.29342 = cfg->cbb;
  D.29343 = D.29342->last_ins;
  MEM[(struct MonoInst *)call].prev = D.29343;
  D.29342 = cfg->cbb;
  D.29342->last_ins = call;
  goto <D.29652>;
  <D.29651>:
  D.29342 = cfg->cbb;
  D.29342 = cfg->cbb;
  D.29342->last_ins = call;
  D.29343 = D.29342->last_ins;
  D.29342->code = D.29343;
  <D.29652>:
  if (rgctx_arg != 0B) goto <D.29653>; else goto <D.29654>;
  <D.29653>:
  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
  <D.29654>:
  D.29393 = call;
  return D.29393;
}


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

  D.29656 = cfg->generic_sharing_context;
  if (D.29656 != 0B) goto <D.29657>; else goto <D.29658>;
  <D.29657>:
  D.29659 = mono_method_check_context_used (method);
  return D.29659;
  <D.29658>:
  D.29659 = 0;
  return D.29659;
}


emit_get_rgctx_method (struct MonoCompile * cfg, int context_used, struct MonoMethod * cmethod, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.29663;
  long int D.29664;
  struct MonoInst * D.29665;
  guint16 iftmp.12;
  long unsigned int D.29667;
  long unsigned int D.29668;
  int D.29672;
  int D.29673;
  const unsigned char * D.29674;
  long int D.29677;
  struct MonoInst * D.29678;
  int D.29679;
  int D.29680;
  int D.29681;
  unsigned int D.29683;
  int D.29684;
  struct MonoBasicBlock * D.29685;
  struct MonoInst * D.29686;
  struct MonoInst * D.29690;
  guint16 iftmp.13;
  long int D.29699;
  struct MonoInst * D.29700;
  int D.29701;
  int D.29702;
  int D.29703;
  unsigned int D.29705;
  int D.29706;
  struct MonoDomain * D.29708;
  struct MonoClass * D.29709;
  struct MonoVTable * D.29710;
  struct MonoGenericContext * D.29711;
  struct MonoGenericInst * D.29712;
  unsigned int D.29713;
  int D.29714;
  struct MonoMethod * D.29718;
  int D.29719;

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

    switch (rgctx_type) <default: <D.26134>, case 5: <D.26127>, case 8: <D.26130>>
    <D.26127>:
    D.29663 = cfg->mempool;
    ins = mono_mempool_alloc (D.29663, 80);
    ins->data.op[1].const_val = 0;
    D.29664 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29664;
    ins->prev = 0B;
    D.29665 = ins->prev;
    ins->next = D.29665;
    D.29667 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29668 = D.29667 & 274877906944;
    if (D.29668 != 0) goto <D.29669>; else goto <D.29670>;
    <D.29669>:
    iftmp.12 = 734;
    goto <D.29671>;
    <D.29670>:
    iftmp.12 = 363;
    <D.29671>:
    ins->opcode = iftmp.12;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29672 = ins->sreg3;
    ins->sreg2 = D.29672;
    D.29673 = ins->sreg2;
    ins->sreg1 = D.29673;
    D.29674 = cfg->ip;
    ins->cil_code = D.29674;
    D.29667 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29668 = D.29667 & 274877906944;
    if (D.29668 != 0) goto <D.29675>; else goto <D.29676>;
    <D.29675>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.29663 = cfg->mempool;
      group = mono_mempool_alloc (D.29663, 80);
      group->data.op[1].const_val = 0;
      D.29677 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.29677;
      group->prev = 0B;
      D.29678 = group->prev;
      group->next = D.29678;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.29679 = group->sreg3;
      group->sreg2 = D.29679;
      D.29680 = group->sreg2;
      group->sreg1 = D.29680;
      D.29674 = cfg->ip;
      group->cil_code = D.29674;
      group->data.op[0].src = cmethod;
      group->data.op[1].src = 6B;
      D.29681 = got_loc->dreg;
      ins->sreg1 = D.29681;
      ins->data.op[1].p = group;
    }
    goto <D.29682>;
    <D.29676>:
    ins->data.op[0].p = cmethod;
    ins->data.op[1].src = 6B;
    <D.29682>:
    ins->type = 3;
    D.29683 = alloc_dreg (cfg, 3);
    D.29684 = (int) D.29683;
    ins->dreg = D.29684;
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    if (D.29686 != 0B) goto <D.29687>; else goto <D.29688>;
    <D.29687>:
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    D.29686->next = ins;
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    ins->prev = D.29686;
    D.29685 = cfg->cbb;
    D.29685->last_ins = ins;
    goto <D.29689>;
    <D.29688>:
    D.29685 = cfg->cbb;
    D.29685 = cfg->cbb;
    D.29685->last_ins = ins;
    D.29686 = D.29685->last_ins;
    D.29685->code = D.29686;
    <D.29689>:
    D.29690 = ins;
    return D.29690;
    <D.26130>:
    D.29667 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29668 = D.29667 & 274877906944;
    if (D.29668 != 0) goto <D.29691>; else goto <D.29692>;
    <D.29691>:
    D.29663 = cfg->mempool;
    ins = mono_mempool_alloc (D.29663, 80);
    ins->data.op[1].const_val = 0;
    D.29664 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29664;
    ins->prev = 0B;
    D.29665 = ins->prev;
    ins->next = D.29665;
    D.29667 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29668 = D.29667 & 274877906944;
    if (D.29668 != 0) goto <D.29694>; else goto <D.29695>;
    <D.29694>:
    iftmp.13 = 734;
    goto <D.29696>;
    <D.29695>:
    iftmp.13 = 363;
    <D.29696>:
    ins->opcode = iftmp.13;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29672 = ins->sreg3;
    ins->sreg2 = D.29672;
    D.29673 = ins->sreg2;
    ins->sreg1 = D.29673;
    D.29674 = cfg->ip;
    ins->cil_code = D.29674;
    D.29667 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29668 = D.29667 & 274877906944;
    if (D.29668 != 0) goto <D.29697>; else goto <D.29698>;
    <D.29697>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.29663 = cfg->mempool;
      group = mono_mempool_alloc (D.29663, 80);
      group->data.op[1].const_val = 0;
      D.29699 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.29699;
      group->prev = 0B;
      D.29700 = group->prev;
      group->next = D.29700;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.29701 = group->sreg3;
      group->sreg2 = D.29701;
      D.29702 = group->sreg2;
      group->sreg1 = D.29702;
      D.29674 = cfg->ip;
      group->cil_code = D.29674;
      group->data.op[0].src = cmethod;
      group->data.op[1].src = 34B;
      D.29703 = got_loc->dreg;
      ins->sreg1 = D.29703;
      ins->data.op[1].p = group;
    }
    goto <D.29704>;
    <D.29698>:
    ins->data.op[0].p = cmethod;
    ins->data.op[1].src = 34B;
    <D.29704>:
    ins->type = 3;
    D.29705 = alloc_dreg (cfg, 3);
    D.29706 = (int) D.29705;
    ins->dreg = D.29706;
    goto <D.29707>;
    <D.29692>:
    {
      struct MonoMethodRuntimeGenericContext * mrgctx;

      D.29708 = cfg->domain;
      D.29709 = cmethod->klass;
      D.29710 = mono_class_vtable (D.29708, D.29709);
      D.29711 = mini_method_get_context (cmethod);
      D.29712 = D.29711->method_inst;
      mrgctx = mono_method_lookup_rgctx (D.29710, D.29712);
      D.29663 = cfg->mempool;
      ins = mono_mempool_alloc (D.29663, 80);
      ins->data.op[1].const_val = 0;
      D.29664 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.29664;
      ins->prev = 0B;
      D.29665 = ins->prev;
      ins->next = D.29665;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.29672 = ins->sreg3;
      ins->sreg2 = D.29672;
      D.29673 = ins->sreg2;
      ins->sreg1 = D.29673;
      D.29674 = cfg->ip;
      ins->cil_code = D.29674;
      ins->data.op[0].p = mrgctx;
      ins->type = 3;
      D.29713 = alloc_dreg (cfg, 3);
      D.29714 = (int) D.29713;
      ins->dreg = D.29714;
    }
    <D.29707>:
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    if (D.29686 != 0B) goto <D.29715>; else goto <D.29716>;
    <D.29715>:
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    D.29686->next = ins;
    D.29685 = cfg->cbb;
    D.29686 = D.29685->last_ins;
    ins->prev = D.29686;
    D.29685 = cfg->cbb;
    D.29685->last_ins = ins;
    goto <D.29717>;
    <D.29716>:
    D.29685 = cfg->cbb;
    D.29685 = cfg->cbb;
    D.29685->last_ins = ins;
    D.29686 = D.29685->last_ins;
    D.29685->code = D.29686;
    <D.29717>:
    D.29690 = ins;
    return D.29690;
    <D.26134>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 3327);
  }
  <D.29662>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    struct MonoInst * rgctx;

    D.29663 = cfg->mempool;
    D.29718 = cfg->current_method;
    D.29719 = context_used & 2;
    entry = mono_patch_info_rgctx_entry_new (D.29663, D.29718, D.29719, 6, cmethod, rgctx_type);
    D.29718 = cfg->current_method;
    rgctx = emit_get_rgctx (cfg, D.29718, context_used);
    D.29690 = emit_rgctx_fetch (cfg, rgctx, entry);
    return D.29690;
  }
}


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.29721;
  struct MonoJumpInfo * D.29722;
  struct MonoJumpInfoRgctxEntry * D.29723;
  struct MonoJumpInfoRgctxEntry * res;

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


emit_get_rgctx (struct MonoCompile * cfg, struct MonoMethod * method, int context_used)
{
  struct MonoGenericSharingContext * D.29725;
  _Bool D.29726;
  long int D.29727;
  long int D.29728;
  short unsigned int D.29731;
  int D.29732;
  int D.29733;
  int D.29736;
  struct MonoClass * D.29739;
  long unsigned int D.29740;
  long unsigned int D.29741;
  struct MonoMemPool * D.29744;
  long int D.29745;
  struct MonoInst * D.29746;
  int D.29747;
  int D.29748;
  const unsigned char * D.29749;
  struct MonoType * * D.29750;
  struct MonoType * D.29751;
  unsigned int D.29752;
  short unsigned int D.29753;
  struct MonoInst * * D.29754;
  struct MonoInst * D.29755;
  struct MonoClass * D.29756;
  int D.29757;
  unsigned char D.29758;
  <unnamed type> D.29759;
  unsigned int D.29760;
  int D.29761;
  short unsigned int D.29762;
  struct MonoClass * D.29765;
  struct MonoBasicBlock * D.29766;
  struct MonoInst * D.29767;
  _Bool D.29773;
  long int D.29774;
  long int D.29775;
  int iftmp.14;
  long unsigned int D.29782;
  long unsigned int D.29783;
  struct MonoGenericContext * D.29785;
  struct MonoGenericInst * D.29786;
  _Bool D.29787;
  long int D.29788;
  long int D.29789;
  long int D.29792;
  struct MonoInst * D.29793;
  int D.29794;
  int D.29795;
  struct MonoInst * * D.29796;
  long int D.29797;
  long unsigned int D.29798;
  long unsigned int D.29799;
  struct MonoInst * * D.29800;
  struct MonoInst * D.29801;
  struct MonoType * D.29802;
  unsigned int D.29803;
  short unsigned int D.29804;
  struct MonoClass * D.29805;
  int D.29806;
  unsigned char D.29807;
  <unnamed type> D.29808;
  unsigned int D.29809;
  int D.29810;
  short unsigned int D.29811;
  struct MonoClass * D.29814;
  struct MonoInst * D.29818;
  long int D.29824;
  struct MonoInst * D.29825;
  int D.29826;
  int D.29827;
  long int D.29828;
  long unsigned int D.29829;
  long unsigned int D.29830;
  struct MonoInst * * D.29831;
  struct MonoInst * D.29832;
  struct MonoType * D.29833;
  unsigned int D.29834;
  short unsigned int D.29835;
  struct MonoClass * D.29836;
  int D.29837;
  unsigned char D.29838;
  <unnamed type> D.29839;
  unsigned int D.29840;
  int D.29841;
  short unsigned int D.29842;
  struct MonoClass * D.29845;
  struct MonoGenericContext * D.29851;
  struct MonoGenericInst * D.29852;
  unsigned int D.29855;
  int D.29856;
  unsigned int D.29860;
  long int D.29861;
  struct MonoInst * D.29862;
  int D.29863;
  int D.29864;
  int D.29865;
  struct MonoInst * this;

  this = 0B;
  D.29725 = cfg->generic_sharing_context;
  D.29726 = D.29725 == 0B;
  D.29727 = (long int) D.29726;
  D.29728 = __builtin_expect (D.29727, 0);
  if (D.29728 != 0) goto <D.29729>; else goto <D.29730>;
  <D.29729>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3189, "cfg->generic_sharing_context");
  <D.29730>:
  D.29731 = method->flags;
  D.29732 = (int) D.29731;
  D.29733 = D.29732 & 16;
  if (D.29733 == 0) goto <D.29734>; else goto <D.29735>;
  <D.29734>:
  D.29736 = context_used & 2;
  if (D.29736 == 0) goto <D.29737>; else goto <D.29738>;
  <D.29737>:
  D.29739 = method->klass;
  D.29740 = BIT_FIELD_REF <*D.29739, 64, 256>;
  D.29741 = D.29740 & 8;
  if (D.29741 == 0) goto <D.29742>; else goto <D.29743>;
  <D.29742>:
  D.29744 = cfg->mempool;
  this = mono_mempool_alloc (D.29744, 80);
  this->data.op[1].const_val = 0;
  D.29745 = this->data.op[1].const_val;
  this->data.op[0].const_val = D.29745;
  this->prev = 0B;
  D.29746 = this->prev;
  this->next = D.29746;
  this->opcode = 424;
  this->flags = 0;
  this->type = 0;
  this->dreg = -1;
  this->sreg3 = -1;
  D.29747 = this->sreg3;
  this->sreg2 = D.29747;
  D.29748 = this->sreg2;
  this->sreg1 = D.29748;
  D.29749 = cfg->ip;
  this->cil_code = D.29749;
  D.29750 = cfg->arg_types;
  D.29751 = *D.29750;
  D.29752 = mono_type_to_regmove (cfg, D.29751);
  D.29753 = (short unsigned int) D.29752;
  this->opcode = D.29753;
  D.29750 = cfg->arg_types;
  D.29751 = *D.29750;
  type_to_eval_stack_type (cfg, D.29751, this);
  D.29754 = cfg->args;
  D.29755 = *D.29754;
  D.29756 = D.29755->klass;
  this->klass = D.29756;
  D.29754 = cfg->args;
  D.29755 = *D.29754;
  D.29757 = D.29755->dreg;
  this->sreg1 = D.29757;
  D.29758 = this->type;
  D.29759 = (<unnamed type>) D.29758;
  D.29760 = alloc_dreg (cfg, D.29759);
  D.29761 = (int) D.29760;
  this->dreg = D.29761;
  D.29762 = this->opcode;
  if (D.29762 == 427) goto <D.29763>; else goto <D.29764>;
  <D.29763>:
  D.29750 = cfg->arg_types;
  D.29751 = *D.29750;
  D.29765 = mono_class_from_mono_type (D.29751);
  this->klass = D.29765;
  <D.29764>:
  D.29766 = cfg->cbb;
  D.29767 = D.29766->last_ins;
  if (D.29767 != 0B) goto <D.29768>; else goto <D.29769>;
  <D.29768>:
  D.29766 = cfg->cbb;
  D.29767 = D.29766->last_ins;
  D.29767->next = this;
  D.29766 = cfg->cbb;
  D.29767 = D.29766->last_ins;
  this->prev = D.29767;
  D.29766 = cfg->cbb;
  D.29766->last_ins = this;
  goto <D.29770>;
  <D.29769>:
  D.29766 = cfg->cbb;
  D.29766 = cfg->cbb;
  D.29766->last_ins = this;
  D.29767 = D.29766->last_ins;
  D.29766->code = D.29767;
  <D.29770>:
  <D.29743>:
  <D.29738>:
  <D.29735>:
  D.29736 = context_used & 2;
  if (D.29736 != 0) goto <D.29771>; else goto <D.29772>;
  <D.29771>:
  {
    struct MonoInst * mrgctx_loc;
    struct MonoInst * mrgctx_var;

    D.29773 = this != 0B;
    D.29774 = (long int) D.29773;
    D.29775 = __builtin_expect (D.29774, 0);
    if (D.29775 != 0) goto <D.29776>; else goto <D.29777>;
    <D.29776>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3199, "!this");
    <D.29777>:
    D.29782 = BIT_FIELD_REF <*method, 64, 256>;
    D.29783 = D.29782 & 4096;
    if (D.29783 == 0) goto <D.29779>; else goto <D.29784>;
    <D.29784>:
    D.29785 = mono_method_get_context (method);
    D.29786 = D.29785->method_inst;
    if (D.29786 == 0B) goto <D.29779>; else goto <D.29780>;
    <D.29779>:
    iftmp.14 = 1;
    goto <D.29781>;
    <D.29780>:
    iftmp.14 = 0;
    <D.29781>:
    D.29787 = iftmp.14 != 0;
    D.29788 = (long int) D.29787;
    D.29789 = __builtin_expect (D.29788, 0);
    if (D.29789 != 0) goto <D.29790>; else goto <D.29791>;
    <D.29790>:
    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.29791>:
    mrgctx_loc = mono_get_vtable_var (cfg);
    D.29744 = cfg->mempool;
    mrgctx_var = mono_mempool_alloc (D.29744, 80);
    mrgctx_var->data.op[1].const_val = 0;
    D.29792 = mrgctx_var->data.op[1].const_val;
    mrgctx_var->data.op[0].const_val = D.29792;
    mrgctx_var->prev = 0B;
    D.29793 = mrgctx_var->prev;
    mrgctx_var->next = D.29793;
    mrgctx_var->opcode = 424;
    mrgctx_var->flags = 0;
    mrgctx_var->type = 0;
    mrgctx_var->dreg = -1;
    mrgctx_var->sreg3 = -1;
    D.29794 = mrgctx_var->sreg3;
    mrgctx_var->sreg2 = D.29794;
    D.29795 = mrgctx_var->sreg2;
    mrgctx_var->sreg1 = D.29795;
    D.29749 = cfg->ip;
    mrgctx_var->cil_code = D.29749;
    D.29796 = cfg->varinfo;
    D.29797 = mrgctx_loc->data.op[0].const_val;
    D.29798 = (long unsigned int) D.29797;
    D.29799 = D.29798 * 8;
    D.29800 = D.29796 + D.29799;
    D.29801 = *D.29800;
    D.29802 = D.29801->data.op[1].vtype;
    D.29803 = mono_type_to_regmove (cfg, D.29802);
    D.29804 = (short unsigned int) D.29803;
    mrgctx_var->opcode = D.29804;
    D.29796 = cfg->varinfo;
    D.29797 = mrgctx_loc->data.op[0].const_val;
    D.29798 = (long unsigned int) D.29797;
    D.29799 = D.29798 * 8;
    D.29800 = D.29796 + D.29799;
    D.29801 = *D.29800;
    D.29802 = D.29801->data.op[1].vtype;
    type_to_eval_stack_type (cfg, D.29802, mrgctx_var);
    D.29796 = cfg->varinfo;
    D.29797 = mrgctx_loc->data.op[0].const_val;
    D.29798 = (long unsigned int) D.29797;
    D.29799 = D.29798 * 8;
    D.29800 = D.29796 + D.29799;
    D.29801 = *D.29800;
    D.29805 = D.29801->klass;
    mrgctx_var->klass = D.29805;
    D.29796 = cfg->varinfo;
    D.29797 = mrgctx_loc->data.op[0].const_val;
    D.29798 = (long unsigned int) D.29797;
    D.29799 = D.29798 * 8;
    D.29800 = D.29796 + D.29799;
    D.29801 = *D.29800;
    D.29806 = D.29801->dreg;
    mrgctx_var->sreg1 = D.29806;
    D.29807 = mrgctx_var->type;
    D.29808 = (<unnamed type>) D.29807;
    D.29809 = alloc_dreg (cfg, D.29808);
    D.29810 = (int) D.29809;
    mrgctx_var->dreg = D.29810;
    D.29811 = mrgctx_var->opcode;
    if (D.29811 == 427) goto <D.29812>; else goto <D.29813>;
    <D.29812>:
    D.29796 = cfg->varinfo;
    D.29797 = mrgctx_loc->data.op[0].const_val;
    D.29798 = (long unsigned int) D.29797;
    D.29799 = D.29798 * 8;
    D.29800 = D.29796 + D.29799;
    D.29801 = *D.29800;
    D.29802 = D.29801->data.op[1].vtype;
    D.29814 = mono_class_from_mono_type (D.29802);
    mrgctx_var->klass = D.29814;
    <D.29813>:
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    if (D.29767 != 0B) goto <D.29815>; else goto <D.29816>;
    <D.29815>:
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    D.29767->next = mrgctx_var;
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    mrgctx_var->prev = D.29767;
    D.29766 = cfg->cbb;
    D.29766->last_ins = mrgctx_var;
    goto <D.29817>;
    <D.29816>:
    D.29766 = cfg->cbb;
    D.29766 = cfg->cbb;
    D.29766->last_ins = mrgctx_var;
    D.29767 = D.29766->last_ins;
    D.29766->code = D.29767;
    <D.29817>:
    D.29818 = mrgctx_var;
    return D.29818;
  }
  <D.29772>:
  D.29731 = method->flags;
  D.29732 = (int) D.29731;
  D.29733 = D.29732 & 16;
  if (D.29733 != 0) goto <D.29819>; else goto <D.29821>;
  <D.29821>:
  D.29739 = method->klass;
  D.29740 = BIT_FIELD_REF <*D.29739, 64, 256>;
  D.29741 = D.29740 & 8;
  if (D.29741 != 0) goto <D.29819>; else goto <D.29820>;
  <D.29819>:
  {
    struct MonoInst * vtable_loc;
    struct MonoInst * vtable_var;

    D.29773 = this != 0B;
    D.29774 = (long int) D.29773;
    D.29775 = __builtin_expect (D.29774, 0);
    if (D.29775 != 0) goto <D.29822>; else goto <D.29823>;
    <D.29822>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3209, "!this");
    <D.29823>:
    vtable_loc = mono_get_vtable_var (cfg);
    D.29744 = cfg->mempool;
    vtable_var = mono_mempool_alloc (D.29744, 80);
    vtable_var->data.op[1].const_val = 0;
    D.29824 = vtable_var->data.op[1].const_val;
    vtable_var->data.op[0].const_val = D.29824;
    vtable_var->prev = 0B;
    D.29825 = vtable_var->prev;
    vtable_var->next = D.29825;
    vtable_var->opcode = 424;
    vtable_var->flags = 0;
    vtable_var->type = 0;
    vtable_var->dreg = -1;
    vtable_var->sreg3 = -1;
    D.29826 = vtable_var->sreg3;
    vtable_var->sreg2 = D.29826;
    D.29827 = vtable_var->sreg2;
    vtable_var->sreg1 = D.29827;
    D.29749 = cfg->ip;
    vtable_var->cil_code = D.29749;
    D.29796 = cfg->varinfo;
    D.29828 = vtable_loc->data.op[0].const_val;
    D.29829 = (long unsigned int) D.29828;
    D.29830 = D.29829 * 8;
    D.29831 = D.29796 + D.29830;
    D.29832 = *D.29831;
    D.29833 = D.29832->data.op[1].vtype;
    D.29834 = mono_type_to_regmove (cfg, D.29833);
    D.29835 = (short unsigned int) D.29834;
    vtable_var->opcode = D.29835;
    D.29796 = cfg->varinfo;
    D.29828 = vtable_loc->data.op[0].const_val;
    D.29829 = (long unsigned int) D.29828;
    D.29830 = D.29829 * 8;
    D.29831 = D.29796 + D.29830;
    D.29832 = *D.29831;
    D.29833 = D.29832->data.op[1].vtype;
    type_to_eval_stack_type (cfg, D.29833, vtable_var);
    D.29796 = cfg->varinfo;
    D.29828 = vtable_loc->data.op[0].const_val;
    D.29829 = (long unsigned int) D.29828;
    D.29830 = D.29829 * 8;
    D.29831 = D.29796 + D.29830;
    D.29832 = *D.29831;
    D.29836 = D.29832->klass;
    vtable_var->klass = D.29836;
    D.29796 = cfg->varinfo;
    D.29828 = vtable_loc->data.op[0].const_val;
    D.29829 = (long unsigned int) D.29828;
    D.29830 = D.29829 * 8;
    D.29831 = D.29796 + D.29830;
    D.29832 = *D.29831;
    D.29837 = D.29832->dreg;
    vtable_var->sreg1 = D.29837;
    D.29838 = vtable_var->type;
    D.29839 = (<unnamed type>) D.29838;
    D.29840 = alloc_dreg (cfg, D.29839);
    D.29841 = (int) D.29840;
    vtable_var->dreg = D.29841;
    D.29842 = vtable_var->opcode;
    if (D.29842 == 427) goto <D.29843>; else goto <D.29844>;
    <D.29843>:
    D.29796 = cfg->varinfo;
    D.29828 = vtable_loc->data.op[0].const_val;
    D.29829 = (long unsigned int) D.29828;
    D.29830 = D.29829 * 8;
    D.29831 = D.29796 + D.29830;
    D.29832 = *D.29831;
    D.29833 = D.29832->data.op[1].vtype;
    D.29845 = mono_class_from_mono_type (D.29833);
    vtable_var->klass = D.29845;
    <D.29844>:
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    if (D.29767 != 0B) goto <D.29846>; else goto <D.29847>;
    <D.29846>:
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    D.29767->next = vtable_var;
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    vtable_var->prev = D.29767;
    D.29766 = cfg->cbb;
    D.29766->last_ins = vtable_var;
    goto <D.29848>;
    <D.29847>:
    D.29766 = cfg->cbb;
    D.29766 = cfg->cbb;
    D.29766->last_ins = vtable_var;
    D.29767 = D.29766->last_ins;
    D.29766->code = D.29767;
    <D.29848>:
    D.29782 = BIT_FIELD_REF <*method, 64, 256>;
    D.29783 = D.29782 & 4096;
    if (D.29783 != 0) goto <D.29849>; else goto <D.29850>;
    <D.29849>:
    D.29851 = mono_method_get_context (method);
    D.29852 = D.29851->method_inst;
    if (D.29852 != 0B) goto <D.29853>; else goto <D.29854>;
    <D.29853>:
    {
      struct MonoInst * mrgctx_var;
      int vtable_reg;

      mrgctx_var = vtable_var;
      D.29855 = alloc_preg (cfg);
      vtable_reg = (int) D.29855;
      D.29744 = cfg->mempool;
      vtable_var = mono_mempool_alloc (D.29744, 80);
      vtable_var->data.op[1].const_val = 0;
      D.29824 = vtable_var->data.op[1].const_val;
      vtable_var->data.op[0].const_val = D.29824;
      vtable_var->prev = 0B;
      D.29825 = vtable_var->prev;
      vtable_var->next = D.29825;
      vtable_var->opcode = 388;
      vtable_var->flags = 0;
      vtable_var->type = 0;
      vtable_var->dreg = -1;
      vtable_var->sreg3 = -1;
      D.29826 = vtable_var->sreg3;
      vtable_var->sreg2 = D.29826;
      D.29827 = vtable_var->sreg2;
      vtable_var->sreg1 = D.29827;
      D.29749 = cfg->ip;
      vtable_var->cil_code = D.29749;
      vtable_var->dreg = vtable_reg;
      D.29856 = mrgctx_var->dreg;
      vtable_var->sreg1 = D.29856;
      vtable_var->data.op[0].const_val = 0;
      vtable_var->type = 1;
      D.29766 = cfg->cbb;
      D.29767 = D.29766->last_ins;
      if (D.29767 != 0B) goto <D.29857>; else goto <D.29858>;
      <D.29857>:
      D.29766 = cfg->cbb;
      D.29767 = D.29766->last_ins;
      D.29767->next = vtable_var;
      D.29766 = cfg->cbb;
      D.29767 = D.29766->last_ins;
      vtable_var->prev = D.29767;
      D.29766 = cfg->cbb;
      D.29766->last_ins = vtable_var;
      goto <D.29859>;
      <D.29858>:
      D.29766 = cfg->cbb;
      D.29766 = cfg->cbb;
      D.29766->last_ins = vtable_var;
      D.29767 = D.29766->last_ins;
      D.29766->code = D.29767;
      <D.29859>:
      vtable_var->type = 3;
    }
    <D.29854>:
    <D.29850>:
    D.29818 = vtable_var;
    return D.29818;
  }
  <D.29820>:
  {
    struct MonoInst * ins;
    int vtable_reg;

    D.29860 = alloc_preg (cfg);
    vtable_reg = (int) D.29860;
    D.29744 = cfg->mempool;
    ins = mono_mempool_alloc (D.29744, 80);
    ins->data.op[1].const_val = 0;
    D.29861 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29861;
    ins->prev = 0B;
    D.29862 = ins->prev;
    ins->next = D.29862;
    ins->opcode = 388;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29863 = ins->sreg3;
    ins->sreg2 = D.29863;
    D.29864 = ins->sreg2;
    ins->sreg1 = D.29864;
    D.29749 = cfg->ip;
    ins->cil_code = D.29749;
    ins->dreg = vtable_reg;
    D.29865 = this->dreg;
    ins->sreg1 = D.29865;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    if (D.29767 != 0B) goto <D.29866>; else goto <D.29867>;
    <D.29866>:
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    D.29767->next = ins;
    D.29766 = cfg->cbb;
    D.29767 = D.29766->last_ins;
    ins->prev = D.29767;
    D.29766 = cfg->cbb;
    D.29766->last_ins = ins;
    goto <D.29868>;
    <D.29867>:
    D.29766 = cfg->cbb;
    D.29766 = cfg->cbb;
    D.29766->last_ins = ins;
    D.29767 = D.29766->last_ins;
    D.29766->code = D.29767;
    <D.29868>:
    D.29818 = ins;
    return D.29818;
  }
}


mono_get_vtable_var (struct MonoCompile * cfg)
{
  struct MonoGenericSharingContext * D.29870;
  _Bool D.29871;
  long int D.29872;
  long int D.29873;
  struct MonoInst * D.29876;
  struct MonoClass * D.29879;
  struct MonoType * D.29880;
  struct MonoInst * D.29881;
  unsigned char D.29882;
  unsigned char D.29883;
  struct MonoInst * D.29884;

  D.29870 = cfg->generic_sharing_context;
  D.29871 = D.29870 == 0B;
  D.29872 = (long int) D.29871;
  D.29873 = __builtin_expect (D.29872, 0);
  if (D.29873 != 0) goto <D.29874>; else goto <D.29875>;
  <D.29874>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1161, "cfg->generic_sharing_context");
  <D.29875>:
  D.29876 = cfg->rgctx_var;
  if (D.29876 == 0B) goto <D.29877>; else goto <D.29878>;
  <D.29877>:
  D.29879 = mono_defaults.int_class;
  D.29880 = &D.29879->byval_arg;
  D.29881 = mono_compile_create_var (cfg, D.29880, 329);
  cfg->rgctx_var = D.29881;
  D.29876 = cfg->rgctx_var;
  D.29876 = cfg->rgctx_var;
  D.29882 = D.29876->flags;
  D.29883 = D.29882 | 4;
  D.29876->flags = D.29883;
  <D.29878>:
  D.29884 = cfg->rgctx_var;
  return D.29884;
}


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

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


mono_emit_abs_call (struct MonoCompile * cfg, MonoJumpInfoType patch_type, const void * data, struct MonoMethodSignature * sig, struct MonoInst * * args)
{
  struct MonoMemPool * D.29889;
  struct GHashTable * D.29890;
  struct GHashTable * D.29893;
  struct MonoInst * D.29894;
  struct MonoJumpInfo * ji;
  struct MonoInst * ins;

  D.29889 = cfg->mempool;
  ji = mono_patch_info_new (D.29889, 0, patch_type, data);
  D.29890 = cfg->abs_patches;
  if (D.29890 == 0B) goto <D.29891>; else goto <D.29892>;
  <D.29891>:
  D.29893 = monoeg_g_hash_table_new (0B, 0B);
  cfg->abs_patches = D.29893;
  <D.29892>:
  D.29890 = cfg->abs_patches;
  monoeg_g_hash_table_insert_replace (D.29890, ji, ji, 0);
  ins = mono_emit_native_call (cfg, ji, sig, args);
  MEM[(struct MonoCallInst *)ins].fptr_is_patch = 1;
  D.29894 = ins;
  return D.29894;
}


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

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


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.29900;
  struct MonoMemPool * D.29901;
  long int D.29902;
  struct MonoInst * D.29903;
  int D.29904;
  int D.29905;
  const unsigned char * D.29906;
  int D.29907;
  struct MonoBasicBlock * D.29908;
  struct MonoInst * D.29909;
  _Bool D.29913;
  int D.29914;
  int D.29915;
  struct MonoInst * D.29923;
  struct MonoCallInst * call;
  int rgctx_reg;

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

    D.29901 = cfg->mempool;
    inst = mono_mempool_alloc (D.29901, 80);
    inst->data.op[1].const_val = 0;
    D.29902 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29902;
    inst->prev = 0B;
    D.29903 = inst->prev;
    inst->next = D.29903;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29904 = inst->sreg3;
    inst->sreg2 = D.29904;
    D.29905 = inst->sreg2;
    inst->sreg1 = D.29905;
    D.29906 = cfg->ip;
    inst->cil_code = D.29906;
    inst->dreg = rgctx_reg;
    D.29907 = rgctx_arg->dreg;
    inst->sreg1 = D.29907;
    D.29908 = cfg->cbb;
    D.29909 = D.29908->last_ins;
    if (D.29909 != 0B) goto <D.29910>; else goto <D.29911>;
    <D.29910>:
    D.29908 = cfg->cbb;
    D.29909 = D.29908->last_ins;
    D.29909->next = inst;
    D.29908 = cfg->cbb;
    D.29909 = D.29908->last_ins;
    inst->prev = D.29909;
    D.29908 = cfg->cbb;
    D.29908->last_ins = inst;
    goto <D.29912>;
    <D.29911>:
    D.29908 = cfg->cbb;
    D.29908 = cfg->cbb;
    D.29908->last_ins = inst;
    D.29909 = D.29908->last_ins;
    D.29908->code = D.29909;
    <D.29912>:
  }
  <D.29899>:
  D.29913 = rgctx_arg != 0B;
  D.29914 = (int) D.29913;
  call = mono_emit_call_args (cfg, sig, args, 1, 0, 0, D.29914, 0);
  D.29915 = addr->dreg;
  call->inst.sreg1 = D.29915;
  if (imt_arg != 0B) goto <D.29916>; else goto <D.29917>;
  <D.29916>:
  emit_imt_argument (cfg, call, 0B, imt_arg);
  <D.29917>:
  D.29908 = cfg->cbb;
  D.29909 = D.29908->last_ins;
  if (D.29909 != 0B) goto <D.29918>; else goto <D.29919>;
  <D.29918>:
  D.29908 = cfg->cbb;
  D.29909 = D.29908->last_ins;
  D.29909->next = call;
  D.29908 = cfg->cbb;
  D.29909 = D.29908->last_ins;
  MEM[(struct MonoInst *)call].prev = D.29909;
  D.29908 = cfg->cbb;
  D.29908->last_ins = call;
  goto <D.29920>;
  <D.29919>:
  D.29908 = cfg->cbb;
  D.29908 = cfg->cbb;
  D.29908->last_ins = call;
  D.29909 = D.29908->last_ins;
  D.29908->code = D.29909;
  <D.29920>:
  if (rgctx_arg != 0B) goto <D.29921>; else goto <D.29922>;
  <D.29921>:
  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
  <D.29922>:
  D.29923 = call;
  return D.29923;
}


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.29927;
  int D.29928;
  int D.29929;
  const unsigned char * D.29930;
  struct MonoType * D.29932;
  struct MonoGenericSharingContext * D.29933;
  int D.29934;
  short unsigned int D.29935;
  unsigned char D.29936;
  <unnamed-unsigned:1> D.29937;
  struct MonoInst * D.29938;
  int D.29941;
  struct MonoInst * D.29944;
  int D.29946;
  <unnamed-unsigned:1> D.29949;
  int D.29950;
  long int D.29951;
  struct MonoInst * D.29952;
  int D.29953;
  int D.29954;
  unsigned int D.29955;
  int D.29956;
  struct MonoBasicBlock * D.29957;
  struct MonoInst * D.29958;
  int D.29962;
  int D.29964;
  unsigned char D.29967;
  <unnamed type> D.29968;
  unsigned int D.29969;
  int D.29970;
  unsigned char D.29971;
  <unnamed-unsigned:1> D.29972;
  unsigned int D.29973;
  unsigned int D.29974;
  unsigned int D.29975;
  unsigned int D.29976;
  unsigned int D.29977;
  struct MonoCallInst * D.29978;
  struct MonoType * sig_ret;
  struct MonoCallInst * call;

  if (tail != 0) goto <D.29925>; else goto <D.29926>;
  <D.29925>:
  D.29927 = cfg->mempool;
  call = mono_mempool_alloc0 (D.29927, 192);
  call->inst.opcode = 444;
  call->inst.dreg = -1;
  call->inst.sreg3 = -1;
  D.29928 = call->inst.sreg3;
  call->inst.sreg2 = D.29928;
  D.29929 = call->inst.sreg2;
  call->inst.sreg1 = D.29929;
  D.29930 = cfg->ip;
  call->inst.cil_code = D.29930;
  goto <D.29931>;
  <D.29926>:
  D.29927 = cfg->mempool;
  call = mono_mempool_alloc0 (D.29927, 192);
  D.29932 = sig->ret;
  D.29933 = cfg->generic_sharing_context;
  D.29934 = ret_type_to_call_opcode (D.29932, calli, virtual, D.29933);
  D.29935 = (short unsigned int) D.29934;
  call->inst.opcode = D.29935;
  call->inst.dreg = -1;
  call->inst.sreg3 = -1;
  D.29928 = call->inst.sreg3;
  call->inst.sreg2 = D.29928;
  D.29929 = call->inst.sreg2;
  call->inst.sreg1 = D.29929;
  D.29930 = cfg->ip;
  call->inst.cil_code = D.29930;
  <D.29931>:
  call->args = args;
  call->signature = sig;
  D.29936 = (unsigned char) rgctx;
  D.29937 = (<unnamed-unsigned:1>) D.29936;
  call->rgctx_reg = D.29937;
  D.29932 = sig->ret;
  sig_ret = mini_replace_type (D.29932);
  D.29938 = &call->inst;
  type_to_eval_stack_type (cfg, sig_ret, D.29938);
  if (tail != 0) goto <D.29939>; else goto <D.29940>;
  <D.29939>:
  D.29941 = mini_type_is_vtype (cfg, sig_ret);
  if (D.29941 != 0) goto <D.29942>; else goto <D.29943>;
  <D.29942>:
  D.29944 = cfg->vret_addr;
  call->vret_var = D.29944;
  <D.29943>:
  goto <D.29945>;
  <D.29940>:
  D.29946 = mini_type_is_vtype (cfg, sig_ret);
  if (D.29946 != 0) goto <D.29947>; else goto <D.29948>;
  <D.29947>:
  {
    struct MonoInst * temp;
    struct MonoInst * loada;

    temp = mono_compile_create_var (cfg, sig_ret, 329);
    D.29949 = sig->pinvoke;
    D.29950 = (int) D.29949;
    temp->backend.is_pinvoke = D.29950;
    D.29927 = cfg->mempool;
    loada = mono_mempool_alloc (D.29927, 80);
    loada->data.op[1].const_val = 0;
    D.29951 = loada->data.op[1].const_val;
    loada->data.op[0].const_val = D.29951;
    loada->prev = 0B;
    D.29952 = loada->prev;
    loada->next = D.29952;
    loada->opcode = 334;
    loada->flags = 0;
    loada->type = 0;
    loada->dreg = -1;
    loada->sreg3 = -1;
    D.29953 = loada->sreg3;
    loada->sreg2 = D.29953;
    D.29954 = loada->sreg2;
    loada->sreg1 = D.29954;
    D.29930 = cfg->ip;
    loada->cil_code = D.29930;
    D.29955 = alloc_preg (cfg);
    D.29956 = (int) D.29955;
    loada->dreg = D.29956;
    loada->data.op[0].p = temp;
    loada->data.op[1].p = call;
    D.29957 = cfg->cbb;
    D.29958 = D.29957->last_ins;
    if (D.29958 != 0B) goto <D.29959>; else goto <D.29960>;
    <D.29959>:
    D.29957 = cfg->cbb;
    D.29958 = D.29957->last_ins;
    D.29958->next = loada;
    D.29957 = cfg->cbb;
    D.29958 = D.29957->last_ins;
    loada->prev = D.29958;
    D.29957 = cfg->cbb;
    D.29957->last_ins = loada;
    goto <D.29961>;
    <D.29960>:
    D.29957 = cfg->cbb;
    D.29957 = cfg->cbb;
    D.29957->last_ins = loada;
    D.29958 = D.29957->last_ins;
    D.29957->code = D.29958;
    <D.29961>:
    D.29962 = temp->dreg;
    call->inst.dreg = D.29962;
    call->vret_var = loada;
  }
  goto <D.29963>;
  <D.29948>:
  D.29964 = mono_type_is_void (sig_ret);
  if (D.29964 == 0) goto <D.29965>; else goto <D.29966>;
  <D.29965>:
  D.29967 = call->inst.type;
  D.29968 = (<unnamed type>) D.29967;
  D.29969 = alloc_dreg (cfg, D.29968);
  D.29970 = (int) D.29969;
  call->inst.dreg = D.29970;
  <D.29966>:
  <D.29963>:
  <D.29945>:
  D.29971 = (unsigned char) unbox_trampoline;
  D.29972 = (<unnamed-unsigned:1>) D.29971;
  call->need_unbox_trampoline = D.29972;
  mono_arch_emit_call (cfg, call);
  D.29973 = call->stack_usage;
  D.29974 = cfg->param_area;
  D.29975 = MAX_EXPR <D.29973, D.29974>;
  cfg->param_area = D.29975;
  D.29976 = cfg->flags;
  D.29977 = D.29976 | 2;
  cfg->flags = D.29977;
  D.29978 = call;
  return D.29978;
}


ret_type_to_call_opcode (struct MonoType * type, int calli, int virt, struct MonoGenericSharingContext * gsctx)
{
  long unsigned int D.29980;
  long unsigned int D.29981;
  int D.29984;
  int iftmp.16;
  int iftmp.17;
  unsigned char D.29993;
  int D.29994;
  int iftmp.18;
  int iftmp.19;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  int iftmp.25;
  int iftmp.26;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  struct MonoClass * D.30043;
  long unsigned int D.30044;
  long unsigned int D.30045;
  int iftmp.30;
  int iftmp.31;
  int iftmp.32;
  int iftmp.33;
  struct MonoGenericClass * D.30064;
  struct MonoClass * D.30065;
  int iftmp.34;
  int iftmp.35;
  void handle_enum = <<< error >>>;

  D.29980 = BIT_FIELD_REF <*type, 64, 64>;
  D.29981 = D.29980 & 1073741824;
  if (D.29981 != 0) goto <D.29982>; else goto <D.29983>;
  <D.29982>:
  if (calli == 0) goto <D.29986>; else goto <D.29987>;
  <D.29986>:
  if (virt != 0) goto <D.29989>; else goto <D.29990>;
  <D.29989>:
  iftmp.17 = 348;
  goto <D.29991>;
  <D.29990>:
  iftmp.17 = 346;
  <D.29991>:
  iftmp.16 = iftmp.17;
  goto <D.29992>;
  <D.29987>:
  iftmp.16 = 347;
  <D.29992>:
  D.29984 = iftmp.16;
  return D.29984;
  <D.29983>:
  handle_enum:
  type = mini_get_basic_type_from_generic (gsctx, type);
  type = mini_replace_type (type);
  D.29993 = type->type;
  D.29994 = (int) D.29993;
  switch (D.29994) <default: <D.25676>, case 1: <D.25649>, case 2: <D.25652>, case 3: <D.25655>, case 4: <D.25650>, case 5: <D.25651>, case 6: <D.25653>, case 7: <D.25654>, case 8: <D.25656>, case 9: <D.25657>, case 10: <D.25667>, case 11: <D.25668>, case 12: <D.25669>, case 13: <D.25670>, case 14: <D.25663>, case 15: <D.25660>, case 17: <D.25671>, case 18: <D.25662>, case 19: <D.25674>, case 20: <D.25666>, case 21: <D.25673>, case 22: <D.25672>, case 24: <D.25658>, case 25: <D.25659>, case 27: <D.25661>, case 28: <D.25664>, case 29: <D.25665>, case 30: <D.25675>>
  <D.25649>:
  if (calli == 0) goto <D.29996>; else goto <D.29997>;
  <D.29996>:
  if (virt != 0) goto <D.29999>; else goto <D.30000>;
  <D.29999>:
  iftmp.19 = 345;
  goto <D.30001>;
  <D.30000>:
  iftmp.19 = 343;
  <D.30001>:
  iftmp.18 = iftmp.19;
  goto <D.30002>;
  <D.29997>:
  iftmp.18 = 344;
  <D.30002>:
  D.29984 = iftmp.18;
  return D.29984;
  <D.25650>:
  <D.25651>:
  <D.25652>:
  <D.25653>:
  <D.25654>:
  <D.25655>:
  <D.25656>:
  <D.25657>:
  if (calli == 0) goto <D.30004>; else goto <D.30005>;
  <D.30004>:
  if (virt != 0) goto <D.30007>; else goto <D.30008>;
  <D.30007>:
  iftmp.21 = 348;
  goto <D.30009>;
  <D.30008>:
  iftmp.21 = 346;
  <D.30009>:
  iftmp.20 = iftmp.21;
  goto <D.30010>;
  <D.30005>:
  iftmp.20 = 347;
  <D.30010>:
  D.29984 = iftmp.20;
  return D.29984;
  <D.25658>:
  <D.25659>:
  <D.25660>:
  <D.25661>:
  if (calli == 0) goto <D.30012>; else goto <D.30013>;
  <D.30012>:
  if (virt != 0) goto <D.30015>; else goto <D.30016>;
  <D.30015>:
  iftmp.23 = 348;
  goto <D.30017>;
  <D.30016>:
  iftmp.23 = 346;
  <D.30017>:
  iftmp.22 = iftmp.23;
  goto <D.30018>;
  <D.30013>:
  iftmp.22 = 347;
  <D.30018>:
  D.29984 = iftmp.22;
  return D.29984;
  <D.25662>:
  <D.25663>:
  <D.25664>:
  <D.25665>:
  <D.25666>:
  if (calli == 0) goto <D.30020>; else goto <D.30021>;
  <D.30020>:
  if (virt != 0) goto <D.30023>; else goto <D.30024>;
  <D.30023>:
  iftmp.25 = 348;
  goto <D.30025>;
  <D.30024>:
  iftmp.25 = 346;
  <D.30025>:
  iftmp.24 = iftmp.25;
  goto <D.30026>;
  <D.30021>:
  iftmp.24 = 347;
  <D.30026>:
  D.29984 = iftmp.24;
  return D.29984;
  <D.25667>:
  <D.25668>:
  if (calli == 0) goto <D.30028>; else goto <D.30029>;
  <D.30028>:
  if (virt != 0) goto <D.30031>; else goto <D.30032>;
  <D.30031>:
  iftmp.27 = 354;
  goto <D.30033>;
  <D.30032>:
  iftmp.27 = 352;
  <D.30033>:
  iftmp.26 = iftmp.27;
  goto <D.30034>;
  <D.30029>:
  iftmp.26 = 353;
  <D.30034>:
  D.29984 = iftmp.26;
  return D.29984;
  <D.25669>:
  <D.25670>:
  if (calli == 0) goto <D.30036>; else goto <D.30037>;
  <D.30036>:
  if (virt != 0) goto <D.30039>; else goto <D.30040>;
  <D.30039>:
  iftmp.29 = 351;
  goto <D.30041>;
  <D.30040>:
  iftmp.29 = 349;
  <D.30041>:
  iftmp.28 = iftmp.29;
  goto <D.30042>;
  <D.30037>:
  iftmp.28 = 350;
  <D.30042>:
  D.29984 = iftmp.28;
  return D.29984;
  <D.25671>:
  D.30043 = type->data.klass;
  D.30044 = BIT_FIELD_REF <*D.30043, 64, 256>;
  D.30045 = D.30044 & 16;
  if (D.30045 != 0) goto <D.30046>; else goto <D.30047>;
  <D.30046>:
  D.30043 = type->data.klass;
  type = mono_class_enum_basetype (D.30043);
  goto handle_enum;
  <D.30047>:
  if (calli == 0) goto <D.30049>; else goto <D.30050>;
  <D.30049>:
  if (virt != 0) goto <D.30052>; else goto <D.30053>;
  <D.30052>:
  iftmp.31 = 357;
  goto <D.30054>;
  <D.30053>:
  iftmp.31 = 355;
  <D.30054>:
  iftmp.30 = iftmp.31;
  goto <D.30055>;
  <D.30050>:
  iftmp.30 = 356;
  <D.30055>:
  D.29984 = iftmp.30;
  return D.29984;
  <D.25672>:
  if (calli == 0) goto <D.30057>; else goto <D.30058>;
  <D.30057>:
  if (virt != 0) goto <D.30060>; else goto <D.30061>;
  <D.30060>:
  iftmp.33 = 357;
  goto <D.30062>;
  <D.30061>:
  iftmp.33 = 355;
  <D.30062>:
  iftmp.32 = iftmp.33;
  goto <D.30063>;
  <D.30058>:
  iftmp.32 = 356;
  <D.30063>:
  D.29984 = iftmp.32;
  return D.29984;
  <D.25673>:
  D.30064 = type->data.generic_class;
  D.30065 = D.30064->container_class;
  type = &D.30065->byval_arg;
  goto handle_enum;
  <D.25674>:
  <D.25675>:
  if (calli == 0) goto <D.30067>; else goto <D.30068>;
  <D.30067>:
  if (virt != 0) goto <D.30070>; else goto <D.30071>;
  <D.30070>:
  iftmp.35 = 357;
  goto <D.30072>;
  <D.30071>:
  iftmp.35 = 355;
  <D.30072>:
  iftmp.34 = iftmp.35;
  goto <D.30073>;
  <D.30068>:
  iftmp.34 = 356;
  <D.30073>:
  D.29984 = iftmp.34;
  return D.29984;
  <D.25676>:
  D.29993 = type->type;
  D.29994 = (int) D.29993;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in ret_type_to_call_opcode", D.29994);
  <D.25677>:
  goto <D.25677>;
  D.29984 = -1;
  return D.29984;
}


callvirt_to_call (int opcode)
{
  int D.30075;

  switch (opcode) <default: <D.25763>, case 345: <D.25759>, case 348: <D.25758>, case 351: <D.25760>, case 354: <D.25762>, case 357: <D.25761>>
  <D.25758>:
  D.30075 = 346;
  return D.30075;
  <D.25759>:
  D.30075 = 343;
  return D.30075;
  <D.25760>:
  D.30075 = 349;
  return D.30075;
  <D.25761>:
  D.30075 = 355;
  return D.30075;
  <D.25762>:
  D.30075 = 352;
  return D.30075;
  <D.25763>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 2288);
  D.30075 = -1;
  return D.30075;
}


mini_emit_load_intf_reg_vtable (struct MonoCompile * cfg, int intf_reg, int vtable_reg, struct MonoClass * klass)
{
  long unsigned int D.30077;
  long unsigned int D.30078;
  unsigned int D.30081;
  unsigned int D.30082;
  struct MonoMemPool * D.30083;
  long int D.30084;
  struct MonoInst * D.30085;
  guint16 iftmp.36;
  int D.30090;
  int D.30091;
  const unsigned char * D.30092;
  long int D.30095;
  struct MonoInst * D.30096;
  int D.30097;
  int D.30098;
  int D.30099;
  unsigned int D.30101;
  int D.30102;
  struct MonoBasicBlock * D.30103;
  struct MonoInst * D.30104;
  long int D.30108;
  struct MonoInst * D.30109;
  int D.30110;
  int D.30111;
  long int D.30115;
  struct MonoInst * D.30116;
  int D.30117;
  int D.30118;
  long int D.30123;
  struct MonoInst * D.30124;
  int D.30125;
  int D.30126;
  short unsigned int D.30127;
  int D.30128;
  int D.30129;
  int D.30130;
  long int D.30131;

  D.30077 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30078 = D.30077 & 274877906944;
  if (D.30078 != 0) goto <D.30079>; else goto <D.30080>;
  <D.30079>:
  {
    int ioffset_reg;
    int iid_reg;

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

      D.30083 = cfg->mempool;
      inst = mono_mempool_alloc (D.30083, 80);
      inst->data.op[1].const_val = 0;
      D.30084 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30084;
      inst->prev = 0B;
      D.30085 = inst->prev;
      inst->next = D.30085;
      D.30077 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30078 = D.30077 & 274877906944;
      if (D.30078 != 0) goto <D.30087>; else goto <D.30088>;
      <D.30087>:
      iftmp.36 = 734;
      goto <D.30089>;
      <D.30088>:
      iftmp.36 = 363;
      <D.30089>:
      inst->opcode = iftmp.36;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30090 = inst->sreg3;
      inst->sreg2 = D.30090;
      D.30091 = inst->sreg2;
      inst->sreg1 = D.30091;
      D.30092 = cfg->ip;
      inst->cil_code = D.30092;
      D.30077 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30078 = D.30077 & 274877906944;
      if (D.30078 != 0) goto <D.30093>; else goto <D.30094>;
      <D.30093>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.30083 = cfg->mempool;
        group = mono_mempool_alloc (D.30083, 80);
        group->data.op[1].const_val = 0;
        D.30095 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.30095;
        group->prev = 0B;
        D.30096 = group->prev;
        group->next = D.30096;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.30097 = group->sreg3;
        group->sreg2 = D.30097;
        D.30098 = group->sreg2;
        group->sreg1 = D.30098;
        D.30092 = cfg->ip;
        group->cil_code = D.30092;
        group->data.op[0].src = klass;
        group->data.op[1].src = 24B;
        D.30099 = got_loc->dreg;
        inst->sreg1 = D.30099;
        inst->data.op[1].p = group;
      }
      goto <D.30100>;
      <D.30094>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 24B;
      <D.30100>:
      inst->type = 3;
      D.30101 = alloc_dreg (cfg, 3);
      D.30102 = (int) D.30101;
      inst->dreg = D.30102;
      inst->dreg = iid_reg;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      if (D.30104 != 0B) goto <D.30105>; else goto <D.30106>;
      <D.30105>:
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      D.30104->next = inst;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      inst->prev = D.30104;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      goto <D.30107>;
      <D.30106>:
      D.30103 = cfg->cbb;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      D.30104 = D.30103->last_ins;
      D.30103->code = D.30104;
      <D.30107>:
    }
    {
      struct MonoInst * inst;

      D.30083 = cfg->mempool;
      inst = mono_mempool_alloc (D.30083, 80);
      inst->data.op[1].const_val = 0;
      D.30108 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30108;
      inst->prev = 0B;
      D.30109 = inst->prev;
      inst->next = D.30109;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30110 = inst->sreg3;
      inst->sreg2 = D.30110;
      D.30111 = inst->sreg2;
      inst->sreg1 = D.30111;
      D.30092 = cfg->ip;
      inst->cil_code = D.30092;
      inst->dreg = ioffset_reg;
      inst->sreg1 = iid_reg;
      inst->sreg2 = vtable_reg;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      if (D.30104 != 0B) goto <D.30112>; else goto <D.30113>;
      <D.30112>:
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      D.30104->next = inst;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      inst->prev = D.30104;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      goto <D.30114>;
      <D.30113>:
      D.30103 = cfg->cbb;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      D.30104 = D.30103->last_ins;
      D.30103->code = D.30104;
      <D.30114>:
    }
    {
      struct MonoInst * inst;

      D.30083 = cfg->mempool;
      inst = mono_mempool_alloc (D.30083, 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 = 388;
      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.30092 = cfg->ip;
      inst->cil_code = D.30092;
      inst->dreg = intf_reg;
      inst->sreg1 = ioffset_reg;
      inst->data.op[0].const_val = 0;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      if (D.30104 != 0B) goto <D.30119>; else goto <D.30120>;
      <D.30119>:
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      D.30104->next = inst;
      D.30103 = cfg->cbb;
      D.30104 = D.30103->last_ins;
      inst->prev = D.30104;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      goto <D.30121>;
      <D.30120>:
      D.30103 = cfg->cbb;
      D.30103 = cfg->cbb;
      D.30103->last_ins = inst;
      D.30104 = D.30103->last_ins;
      D.30103->code = D.30104;
      <D.30121>:
    }
  }
  goto <D.30122>;
  <D.30080>:
  {
    struct MonoInst * inst;

    D.30083 = cfg->mempool;
    inst = mono_mempool_alloc (D.30083, 80);
    inst->data.op[1].const_val = 0;
    D.30123 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30123;
    inst->prev = 0B;
    D.30124 = inst->prev;
    inst->next = D.30124;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30125 = inst->sreg3;
    inst->sreg2 = D.30125;
    D.30126 = inst->sreg2;
    inst->sreg1 = D.30126;
    D.30092 = cfg->ip;
    inst->cil_code = D.30092;
    inst->dreg = intf_reg;
    inst->sreg1 = vtable_reg;
    D.30127 = klass->interface_id;
    D.30128 = (int) D.30127;
    D.30129 = ~D.30128;
    D.30130 = D.30129 * 8;
    D.30131 = (long int) D.30130;
    inst->data.op[0].const_val = D.30131;
    D.30103 = cfg->cbb;
    D.30104 = D.30103->last_ins;
    if (D.30104 != 0B) goto <D.30132>; else goto <D.30133>;
    <D.30132>:
    D.30103 = cfg->cbb;
    D.30104 = D.30103->last_ins;
    D.30104->next = inst;
    D.30103 = cfg->cbb;
    D.30104 = D.30103->last_ins;
    inst->prev = D.30104;
    D.30103 = cfg->cbb;
    D.30103->last_ins = inst;
    goto <D.30134>;
    <D.30133>:
    D.30103 = cfg->cbb;
    D.30103 = cfg->cbb;
    D.30103->last_ins = inst;
    D.30104 = D.30103->last_ins;
    D.30103->code = D.30104;
    <D.30134>:
  }
  <D.30122>:
}


emit_imt_argument (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoMethod * method, struct MonoInst * imt_arg)
{
  unsigned int D.30137;
  struct MonoMemPool * D.30140;
  long int D.30141;
  struct MonoInst * D.30142;
  int D.30143;
  int D.30144;
  const unsigned char * D.30145;
  int D.30146;
  struct MonoBasicBlock * D.30147;
  struct MonoInst * D.30148;
  long unsigned int D.30153;
  long unsigned int D.30154;
  long int D.30157;
  struct MonoInst * D.30158;
  guint16 iftmp.37;
  int D.30163;
  int D.30164;
  long int D.30167;
  struct MonoInst * D.30168;
  int D.30169;
  int D.30170;
  int D.30171;
  unsigned int D.30173;
  int D.30174;
  long int D.30179;
  struct MonoInst * D.30180;
  int D.30181;
  int D.30182;
  unsigned int D.30186;
  long int D.30189;
  struct MonoInst * D.30190;
  int D.30191;
  int D.30192;
  long int D.30199;
  struct MonoInst * D.30200;
  guint16 iftmp.38;
  int D.30205;
  int D.30206;
  long int D.30209;
  struct MonoInst * D.30210;
  int D.30211;
  int D.30212;
  int D.30213;
  unsigned int D.30215;
  int D.30216;
  long int D.30221;
  struct MonoInst * D.30222;
  int D.30223;
  int D.30224;
  int method_reg;

  if (0 != 0) goto <D.30135>; else goto <D.30136>;
  <D.30135>:
  D.30137 = alloc_preg (cfg);
  method_reg = (int) D.30137;
  if (imt_arg != 0B) goto <D.30138>; else goto <D.30139>;
  <D.30138>:
  {
    struct MonoInst * inst;

    D.30140 = cfg->mempool;
    inst = mono_mempool_alloc (D.30140, 80);
    inst->data.op[1].const_val = 0;
    D.30141 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30141;
    inst->prev = 0B;
    D.30142 = inst->prev;
    inst->next = D.30142;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30143 = inst->sreg3;
    inst->sreg2 = D.30143;
    D.30144 = inst->sreg2;
    inst->sreg1 = D.30144;
    D.30145 = cfg->ip;
    inst->cil_code = D.30145;
    inst->dreg = method_reg;
    D.30146 = imt_arg->dreg;
    inst->sreg1 = D.30146;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30149>; else goto <D.30150>;
    <D.30149>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = inst;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    inst->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    goto <D.30151>;
    <D.30150>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30151>:
  }
  goto <D.30152>;
  <D.30139>:
  D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30154 = D.30153 & 274877906944;
  if (D.30154 != 0) goto <D.30155>; else goto <D.30156>;
  <D.30155>:
  {
    struct MonoInst * inst;

    D.30140 = cfg->mempool;
    inst = mono_mempool_alloc (D.30140, 80);
    inst->data.op[1].const_val = 0;
    D.30157 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30157;
    inst->prev = 0B;
    D.30158 = inst->prev;
    inst->next = D.30158;
    D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.30154 = D.30153 & 274877906944;
    if (D.30154 != 0) goto <D.30160>; else goto <D.30161>;
    <D.30160>:
    iftmp.37 = 734;
    goto <D.30162>;
    <D.30161>:
    iftmp.37 = 363;
    <D.30162>:
    inst->opcode = iftmp.37;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30163 = inst->sreg3;
    inst->sreg2 = D.30163;
    D.30164 = inst->sreg2;
    inst->sreg1 = D.30164;
    D.30145 = cfg->ip;
    inst->cil_code = D.30145;
    D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.30154 = D.30153 & 274877906944;
    if (D.30154 != 0) goto <D.30165>; else goto <D.30166>;
    <D.30165>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.30140 = cfg->mempool;
      group = mono_mempool_alloc (D.30140, 80);
      group->data.op[1].const_val = 0;
      D.30167 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.30167;
      group->prev = 0B;
      D.30168 = group->prev;
      group->next = D.30168;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.30169 = group->sreg3;
      group->sreg2 = D.30169;
      D.30170 = group->sreg2;
      group->sreg1 = D.30170;
      D.30145 = cfg->ip;
      group->cil_code = D.30145;
      group->data.op[0].src = method;
      group->data.op[1].src = 6B;
      D.30171 = got_loc->dreg;
      inst->sreg1 = D.30171;
      inst->data.op[1].p = group;
    }
    goto <D.30172>;
    <D.30166>:
    inst->data.op[0].p = method;
    inst->data.op[1].src = 6B;
    <D.30172>:
    inst->type = 3;
    D.30173 = alloc_dreg (cfg, 3);
    D.30174 = (int) D.30173;
    inst->dreg = D.30174;
    inst->dreg = method_reg;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30175>; else goto <D.30176>;
    <D.30175>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = inst;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    inst->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    goto <D.30177>;
    <D.30176>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30177>:
  }
  goto <D.30178>;
  <D.30156>:
  {
    struct MonoInst * ins;

    D.30140 = cfg->mempool;
    ins = mono_mempool_alloc (D.30140, 80);
    ins->data.op[1].const_val = 0;
    D.30179 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30179;
    ins->prev = 0B;
    D.30180 = ins->prev;
    ins->next = D.30180;
    ins->opcode = 363;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30181 = ins->sreg3;
    ins->sreg2 = D.30181;
    D.30182 = ins->sreg2;
    ins->sreg1 = D.30182;
    D.30145 = cfg->ip;
    ins->cil_code = D.30145;
    ins->data.op[0].p = method;
    ins->dreg = method_reg;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30183>; else goto <D.30184>;
    <D.30183>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = ins;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    ins->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = ins;
    goto <D.30185>;
    <D.30184>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = ins;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30185>:
  }
  <D.30178>:
  <D.30152>:
  mono_call_inst_add_outarg_reg (cfg, call, method_reg, 12, 0);
  return;
  <D.30136>:
  D.30186 = alloc_preg (cfg);
  method_reg = (int) D.30186;
  if (imt_arg != 0B) goto <D.30187>; else goto <D.30188>;
  <D.30187>:
  {
    struct MonoInst * inst;

    D.30140 = cfg->mempool;
    inst = mono_mempool_alloc (D.30140, 80);
    inst->data.op[1].const_val = 0;
    D.30189 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30189;
    inst->prev = 0B;
    D.30190 = inst->prev;
    inst->next = D.30190;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30191 = inst->sreg3;
    inst->sreg2 = D.30191;
    D.30192 = inst->sreg2;
    inst->sreg1 = D.30192;
    D.30145 = cfg->ip;
    inst->cil_code = D.30145;
    inst->dreg = method_reg;
    D.30146 = imt_arg->dreg;
    inst->sreg1 = D.30146;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30193>; else goto <D.30194>;
    <D.30193>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = inst;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    inst->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    goto <D.30195>;
    <D.30194>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30195>:
  }
  goto <D.30196>;
  <D.30188>:
  D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30154 = D.30153 & 274877906944;
  if (D.30154 != 0) goto <D.30197>; else goto <D.30198>;
  <D.30197>:
  {
    struct MonoInst * inst;

    D.30140 = cfg->mempool;
    inst = mono_mempool_alloc (D.30140, 80);
    inst->data.op[1].const_val = 0;
    D.30199 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30199;
    inst->prev = 0B;
    D.30200 = inst->prev;
    inst->next = D.30200;
    D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.30154 = D.30153 & 274877906944;
    if (D.30154 != 0) goto <D.30202>; else goto <D.30203>;
    <D.30202>:
    iftmp.38 = 734;
    goto <D.30204>;
    <D.30203>:
    iftmp.38 = 363;
    <D.30204>:
    inst->opcode = iftmp.38;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30205 = inst->sreg3;
    inst->sreg2 = D.30205;
    D.30206 = inst->sreg2;
    inst->sreg1 = D.30206;
    D.30145 = cfg->ip;
    inst->cil_code = D.30145;
    D.30153 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.30154 = D.30153 & 274877906944;
    if (D.30154 != 0) goto <D.30207>; else goto <D.30208>;
    <D.30207>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.30140 = cfg->mempool;
      group = mono_mempool_alloc (D.30140, 80);
      group->data.op[1].const_val = 0;
      D.30209 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.30209;
      group->prev = 0B;
      D.30210 = group->prev;
      group->next = D.30210;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.30211 = group->sreg3;
      group->sreg2 = D.30211;
      D.30212 = group->sreg2;
      group->sreg1 = D.30212;
      D.30145 = cfg->ip;
      group->cil_code = D.30145;
      group->data.op[0].src = method;
      group->data.op[1].src = 6B;
      D.30213 = got_loc->dreg;
      inst->sreg1 = D.30213;
      inst->data.op[1].p = group;
    }
    goto <D.30214>;
    <D.30208>:
    inst->data.op[0].p = method;
    inst->data.op[1].src = 6B;
    <D.30214>:
    inst->type = 3;
    D.30215 = alloc_dreg (cfg, 3);
    D.30216 = (int) D.30215;
    inst->dreg = D.30216;
    inst->dreg = method_reg;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30217>; else goto <D.30218>;
    <D.30217>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = inst;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    inst->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    goto <D.30219>;
    <D.30218>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = inst;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30219>:
  }
  goto <D.30220>;
  <D.30198>:
  {
    struct MonoInst * ins;

    D.30140 = cfg->mempool;
    ins = mono_mempool_alloc (D.30140, 80);
    ins->data.op[1].const_val = 0;
    D.30221 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30221;
    ins->prev = 0B;
    D.30222 = ins->prev;
    ins->next = D.30222;
    ins->opcode = 363;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30223 = ins->sreg3;
    ins->sreg2 = D.30223;
    D.30224 = ins->sreg2;
    ins->sreg1 = D.30224;
    D.30145 = cfg->ip;
    ins->cil_code = D.30145;
    ins->data.op[0].p = method;
    ins->dreg = method_reg;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    if (D.30148 != 0B) goto <D.30225>; else goto <D.30226>;
    <D.30225>:
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    D.30148->next = ins;
    D.30147 = cfg->cbb;
    D.30148 = D.30147->last_ins;
    ins->prev = D.30148;
    D.30147 = cfg->cbb;
    D.30147->last_ins = ins;
    goto <D.30227>;
    <D.30226>:
    D.30147 = cfg->cbb;
    D.30147 = cfg->cbb;
    D.30147->last_ins = ins;
    D.30148 = D.30147->last_ins;
    D.30147->code = D.30148;
    <D.30227>:
  }
  <D.30220>:
  <D.30196>:
  mono_call_inst_add_outarg_reg (cfg, call, method_reg, 12, 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, 12, 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.30229;
  long int D.30230;
  long int D.30231;
  struct MonoBasicBlock * D.30234;
  struct MonoInst * D.30235;
  struct MonoInst * D.30239;
  struct MonoCallInst * call;

  D.30229 = sig == 0B;
  D.30230 = (long int) D.30229;
  D.30231 = __builtin_expect (D.30230, 0);
  if (D.30231 != 0) goto <D.30232>; else goto <D.30233>;
  <D.30232>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2775, "sig");
  <D.30233>:
  call = mono_emit_call_args (cfg, sig, args, 0, 0, 0, 0, 0);
  call->fptr = func;
  D.30234 = cfg->cbb;
  D.30235 = D.30234->last_ins;
  if (D.30235 != 0B) goto <D.30236>; else goto <D.30237>;
  <D.30236>:
  D.30234 = cfg->cbb;
  D.30235 = D.30234->last_ins;
  D.30235->next = call;
  D.30234 = cfg->cbb;
  D.30235 = D.30234->last_ins;
  MEM[(struct MonoInst *)call].prev = D.30235;
  D.30234 = cfg->cbb;
  D.30234->last_ins = call;
  goto <D.30238>;
  <D.30237>:
  D.30234 = cfg->cbb;
  D.30234 = cfg->cbb;
  D.30234->last_ins = call;
  D.30235 = D.30234->last_ins;
  D.30234->code = D.30235;
  <D.30238>:
  D.30239 = call;
  return D.30239;
}


mono_emit_jit_icall (struct MonoCompile * cfg, const void * func, struct MonoInst * * args)
{
  _Bool D.30241;
  long int D.30242;
  long int D.30243;
  struct MonoInst * D.30246;
  const void * D.30247;
  struct MonoMethodSignature * D.30248;
  struct MonoJitICallInfo * info;

  info = mono_find_jit_icall_by_addr (func);
  D.30241 = info == 0B;
  D.30242 = (long int) D.30241;
  D.30243 = __builtin_expect (D.30242, 0);
  if (D.30243 != 0) goto <D.30244>; else goto <D.30245>;
  <D.30244>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2790, "info");
  <D.30245>:
  D.30247 = mono_icall_get_wrapper (info);
  D.30248 = info->sig;
  D.30246 = mono_emit_native_call (cfg, D.30247, D.30248, args);
  return D.30246;
}


mini_emit_stobj (struct MonoCompile * cfg, struct MonoInst * dest, struct MonoInst * src, struct MonoClass * klass, gboolean native)
{
  _Bool D.30250;
  long int D.30251;
  long int D.30252;
  int D.30255;
  _Bool D.30258;
  long int D.30259;
  long int D.30260;
  long unsigned int D.30268;
  long unsigned int D.30269;
  long unsigned int D.30272;
  long unsigned int D.30273;
  short unsigned int D.30279;
  int D.30281;
  unsigned int D.30282;
  unsigned int D.30283;
  unsigned int D.30288;
  unsigned int D.30289;
  unsigned int align.39;
  int align.40;
  int D.30293;
  struct MonoInst * D.30297;
  long unsigned int D.30299;
  struct MonoMemPool * D.30302;
  void * D.30303;
  struct MonoInst * D.30304;
  long int D.30305;
  struct MonoInst * D.30306;
  guint16 iftmp.41;
  int D.30311;
  int D.30312;
  const unsigned char * D.30313;
  long int D.30316;
  struct MonoInst * D.30317;
  int D.30318;
  int D.30319;
  int D.30320;
  unsigned int D.30322;
  int D.30323;
  struct MonoBasicBlock * D.30324;
  struct MonoInst * D.30325;
  void * D.30330;
  unsigned int D.30331;
  int D.30332;
  unsigned int n.42;
  int D.30345;
  int D.30346;
  void * D.30350;
  long int D.30351;
  unsigned int D.30352;
  int D.30353;
  struct MonoMethodSignature * D.30359;
  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.30250 = klass == 0B;
      D.30251 = (long int) D.30250;
      D.30252 = __builtin_expect (D.30251, 0);
      if (D.30252 != 0) goto <D.30253>; else goto <D.30254>;
      <D.30253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3060, "klass");
      <D.30254>:
      D.30255 = mini_is_gsharedvt_klass (cfg, klass);
      if (D.30255 != 0) goto <D.30256>; else goto <D.30257>;
      <D.30256>:
      D.30258 = native != 0;
      D.30259 = (long int) D.30258;
      D.30260 = __builtin_expect (D.30259, 0);
      if (D.30260 != 0) goto <D.30261>; else goto <D.30262>;
      <D.30261>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3067, "!native");
      <D.30262>:
      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.30257>:
      if (native != 0) goto <D.30263>; else goto <D.30264>;
      <D.30263>:
      n = mono_class_native_size (klass, &align);
      goto <D.30265>;
      <D.30264>:
      n = mono_class_value_size (klass, &align);
      <D.30265>:
      D.30268 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30269 = D.30268 & 1152921504606846976;
      if (D.30269 != 0) goto <D.30270>; else goto <D.30271>;
      <D.30270>:
      D.30272 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30273 = D.30272 & 134217728;
      if (D.30273 != 0) goto <D.30266>; else goto <D.30274>;
      <D.30274>:
      if (size_ins != 0B) goto <D.30266>; else goto <D.30267>;
      <D.30266>:
      if (native == 0) goto <D.30275>; else goto <D.30276>;
      <D.30275>:
      D.30279 = dest->opcode;
      if (D.30279 != 429) goto <D.30277>; else goto <D.30280>;
      <D.30280>:
      D.30281 = dest->sreg1;
      D.30282 = (unsigned int) D.30281;
      D.30283 = cfg->frame_reg;
      if (D.30282 != D.30283) goto <D.30277>; else goto <D.30278>;
      <D.30277>:
      D.30279 = dest->opcode;
      if (D.30279 != 314) goto <D.30284>; else goto <D.30285>;
      <D.30284>:
      {
        int context_used;

        iargs[0] = dest;
        iargs[1] = src;
        context_used = mini_class_check_context_used (cfg, klass);
        if (size_ins == 0B) goto <D.30287>; else goto <D.30286>;
        <D.30287>:
        D.30288 = cfg->opt;
        D.30289 = D.30288 & 2048;
        if (D.30289 != 0) goto <D.30290>; else goto <D.30286>;
        <D.30290>:
        align.39 = align;
        align.40 = (int) align.39;
        D.30293 = mono_emit_wb_aware_memcpy (cfg, klass, &iargs, n, align.40);
        if (D.30293 != 0) goto <D.30294>; else goto <D.30286>;
        <D.30294>:
        return;
        <D.30286>:
        if (context_used != 0) goto <D.30295>; else goto <D.30296>;
        <D.30295>:
        D.30297 = emit_get_rgctx_klass (cfg, context_used, klass, 1);
        iargs[2] = D.30297;
        goto <D.30298>;
        <D.30296>:
        D.30268 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30299 = D.30268 & 274877906944;
        if (D.30299 != 0) goto <D.30300>; else goto <D.30301>;
        <D.30300>:
        D.30302 = cfg->mempool;
        D.30303 = mono_mempool_alloc (D.30302, 80);
        iargs[2] = D.30303;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->data.op[1].const_val = 0;
        D.30305 = D.30304->data.op[1].const_val;
        D.30304->data.op[0].const_val = D.30305;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->prev = 0B;
        D.30306 = D.30304->prev;
        D.30304->next = D.30306;
        D.30304 = iargs[2];
        D.30268 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30299 = D.30268 & 274877906944;
        if (D.30299 != 0) goto <D.30308>; else goto <D.30309>;
        <D.30308>:
        iftmp.41 = 734;
        goto <D.30310>;
        <D.30309>:
        iftmp.41 = 363;
        <D.30310>:
        D.30304->opcode = iftmp.41;
        D.30304 = iargs[2];
        D.30304->flags = 0;
        D.30304 = iargs[2];
        D.30304->type = 0;
        D.30304 = iargs[2];
        D.30304->dreg = -1;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->sreg3 = -1;
        D.30311 = D.30304->sreg3;
        D.30304->sreg2 = D.30311;
        D.30312 = D.30304->sreg2;
        D.30304->sreg1 = D.30312;
        D.30304 = iargs[2];
        D.30313 = cfg->ip;
        D.30304->cil_code = D.30313;
        D.30268 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30299 = D.30268 & 274877906944;
        if (D.30299 != 0) goto <D.30314>; else goto <D.30315>;
        <D.30314>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.30302 = cfg->mempool;
          group = mono_mempool_alloc (D.30302, 80);
          group->data.op[1].const_val = 0;
          D.30316 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.30316;
          group->prev = 0B;
          D.30317 = group->prev;
          group->next = D.30317;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.30318 = group->sreg3;
          group->sreg2 = D.30318;
          D.30319 = group->sreg2;
          group->sreg1 = D.30319;
          D.30313 = cfg->ip;
          group->cil_code = D.30313;
          group->data.op[0].src = klass;
          group->data.op[1].src = 11B;
          D.30304 = iargs[2];
          D.30320 = got_loc->dreg;
          D.30304->sreg1 = D.30320;
          D.30304 = iargs[2];
          D.30304->data.op[1].p = group;
        }
        goto <D.30321>;
        <D.30315>:
        D.30304 = iargs[2];
        D.30304->data.op[0].p = klass;
        D.30304 = iargs[2];
        D.30304->data.op[1].src = 11B;
        <D.30321>:
        D.30304 = iargs[2];
        D.30304->type = 3;
        D.30304 = iargs[2];
        D.30322 = alloc_dreg (cfg, 3);
        D.30323 = (int) D.30322;
        D.30304->dreg = D.30323;
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        if (D.30325 != 0B) goto <D.30326>; else goto <D.30327>;
        <D.30326>:
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        D.30304 = iargs[2];
        D.30325->next = D.30304;
        D.30304 = iargs[2];
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        D.30304->prev = D.30325;
        D.30324 = cfg->cbb;
        D.30304 = iargs[2];
        D.30324->last_ins = D.30304;
        goto <D.30328>;
        <D.30327>:
        D.30324 = cfg->cbb;
        D.30324 = cfg->cbb;
        D.30304 = iargs[2];
        D.30324->last_ins = D.30304;
        D.30325 = D.30324->last_ins;
        D.30324->code = D.30325;
        <D.30328>:
        goto <D.30329>;
        <D.30301>:
        D.30302 = cfg->mempool;
        D.30330 = mono_mempool_alloc (D.30302, 80);
        iargs[2] = D.30330;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->data.op[1].const_val = 0;
        D.30305 = D.30304->data.op[1].const_val;
        D.30304->data.op[0].const_val = D.30305;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->prev = 0B;
        D.30306 = D.30304->prev;
        D.30304->next = D.30306;
        D.30304 = iargs[2];
        D.30304->opcode = 363;
        D.30304 = iargs[2];
        D.30304->flags = 0;
        D.30304 = iargs[2];
        D.30304->type = 0;
        D.30304 = iargs[2];
        D.30304->dreg = -1;
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304 = iargs[2];
        D.30304->sreg3 = -1;
        D.30311 = D.30304->sreg3;
        D.30304->sreg2 = D.30311;
        D.30312 = D.30304->sreg2;
        D.30304->sreg1 = D.30312;
        D.30304 = iargs[2];
        D.30313 = cfg->ip;
        D.30304->cil_code = D.30313;
        D.30304 = iargs[2];
        D.30304->data.op[0].p = klass;
        D.30304 = iargs[2];
        D.30304->type = 3;
        D.30304 = iargs[2];
        D.30331 = alloc_dreg (cfg, 3);
        D.30332 = (int) D.30331;
        D.30304->dreg = D.30332;
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        if (D.30325 != 0B) goto <D.30333>; else goto <D.30334>;
        <D.30333>:
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        D.30304 = iargs[2];
        D.30325->next = D.30304;
        D.30304 = iargs[2];
        D.30324 = cfg->cbb;
        D.30325 = D.30324->last_ins;
        D.30304->prev = D.30325;
        D.30324 = cfg->cbb;
        D.30304 = iargs[2];
        D.30324->last_ins = D.30304;
        goto <D.30335>;
        <D.30334>:
        D.30324 = cfg->cbb;
        D.30324 = cfg->cbb;
        D.30304 = iargs[2];
        D.30324->last_ins = D.30304;
        D.30325 = D.30324->last_ins;
        D.30324->code = D.30325;
        <D.30335>:
        mono_class_compute_gc_descriptor (klass);
        <D.30329>:
        <D.30298>:
        if (size_ins != 0B) goto <D.30336>; else goto <D.30337>;
        <D.30336>:
        mono_emit_jit_icall (cfg, mono_gsharedvt_value_copy, &iargs);
        goto <D.30338>;
        <D.30337>:
        mono_emit_jit_icall (cfg, mono_value_copy, &iargs);
        <D.30338>:
        return;
      }
      <D.30285>:
      <D.30278>:
      <D.30276>:
      <D.30267>:
      <D.30271>:
      if (size_ins == 0B) goto <D.30341>; else goto <D.30339>;
      <D.30341>:
      D.30288 = cfg->opt;
      D.30289 = D.30288 & 2048;
      if (D.30289 != 0) goto <D.30342>; else goto <D.30339>;
      <D.30342>:
      n.42 = (unsigned int) n;
      if (n.42 <= 40) goto <D.30344>; else goto <D.30339>;
      <D.30344>:
      D.30345 = dest->dreg;
      D.30346 = src->dreg;
      align.39 = align;
      align.40 = (int) align.39;
      mini_emit_memcpy (cfg, D.30345, 0, D.30346, 0, n, align.40);
      goto <D.30340>;
      <D.30339>:
      iargs[0] = dest;
      iargs[1] = src;
      if (size_ins != 0B) goto <D.30347>; else goto <D.30348>;
      <D.30347>:
      iargs[2] = size_ins;
      goto <D.30349>;
      <D.30348>:
      D.30302 = cfg->mempool;
      D.30350 = mono_mempool_alloc (D.30302, 80);
      iargs[2] = D.30350;
      D.30304 = iargs[2];
      D.30304 = iargs[2];
      D.30304->data.op[1].const_val = 0;
      D.30305 = D.30304->data.op[1].const_val;
      D.30304->data.op[0].const_val = D.30305;
      D.30304 = iargs[2];
      D.30304 = iargs[2];
      D.30304->prev = 0B;
      D.30306 = D.30304->prev;
      D.30304->next = D.30306;
      D.30304 = iargs[2];
      D.30304->opcode = 362;
      D.30304 = iargs[2];
      D.30304->flags = 0;
      D.30304 = iargs[2];
      D.30304->type = 0;
      D.30304 = iargs[2];
      D.30304->dreg = -1;
      D.30304 = iargs[2];
      D.30304 = iargs[2];
      D.30304 = iargs[2];
      D.30304->sreg3 = -1;
      D.30311 = D.30304->sreg3;
      D.30304->sreg2 = D.30311;
      D.30312 = D.30304->sreg2;
      D.30304->sreg1 = D.30312;
      D.30304 = iargs[2];
      D.30313 = cfg->ip;
      D.30304->cil_code = D.30313;
      D.30304 = iargs[2];
      D.30351 = (long int) n;
      D.30304->data.op[0].const_val = D.30351;
      D.30304 = iargs[2];
      D.30304->type = 1;
      D.30304 = iargs[2];
      D.30352 = alloc_dreg (cfg, 1);
      D.30353 = (int) D.30352;
      D.30304->dreg = D.30353;
      D.30324 = cfg->cbb;
      D.30325 = D.30324->last_ins;
      if (D.30325 != 0B) goto <D.30354>; else goto <D.30355>;
      <D.30354>:
      D.30324 = cfg->cbb;
      D.30325 = D.30324->last_ins;
      D.30304 = iargs[2];
      D.30325->next = D.30304;
      D.30304 = iargs[2];
      D.30324 = cfg->cbb;
      D.30325 = D.30324->last_ins;
      D.30304->prev = D.30325;
      D.30324 = cfg->cbb;
      D.30304 = iargs[2];
      D.30324->last_ins = D.30304;
      goto <D.30356>;
      <D.30355>:
      D.30324 = cfg->cbb;
      D.30324 = cfg->cbb;
      D.30304 = iargs[2];
      D.30324->last_ins = D.30304;
      D.30325 = D.30324->last_ins;
      D.30324->code = D.30325;
      <D.30356>:
      <D.30349>:
      memcpy_method = get_memcpy_method ();
      if (memcpy_ins != 0B) goto <D.30357>; else goto <D.30358>;
      <D.30357>:
      D.30359 = mono_method_signature (memcpy_method);
      mono_emit_calli (cfg, D.30359, &iargs, memcpy_ins, 0B, 0B);
      goto <D.30360>;
      <D.30358>:
      mono_emit_method_call (cfg, memcpy_method, &iargs, 0B);
      <D.30360>:
      <D.30340>:
    }
  finally
    {
      iargs = {CLOBBER};
      align = {CLOBBER};
    }
}


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

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


emit_get_gsharedvt_info (struct MonoCompile * cfg, void * data, MonoRgctxInfoType rgctx_type)
{
  unsigned int D.30367;
  struct MonoMemPool * D.30368;
  long int D.30369;
  struct MonoInst * D.30370;
  int D.30371;
  int D.30372;
  const unsigned char * D.30373;
  struct MonoInst * D.30374;
  int D.30375;
  long unsigned int D.30376;
  long unsigned int D.30377;
  long unsigned int D.30378;
  long int D.30379;
  struct MonoBasicBlock * D.30380;
  struct MonoInst * D.30381;
  struct MonoInst * D.30385;
  struct MonoInst * ins;
  int idx;
  int dreg;

  idx = get_gsharedvt_info_slot (cfg, data, rgctx_type);
  D.30367 = alloc_preg (cfg);
  dreg = (int) D.30367;
  D.30368 = cfg->mempool;
  ins = mono_mempool_alloc (D.30368, 80);
  ins->data.op[1].const_val = 0;
  D.30369 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.30369;
  ins->prev = 0B;
  D.30370 = ins->prev;
  ins->next = D.30370;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.30371 = ins->sreg3;
  ins->sreg2 = D.30371;
  D.30372 = ins->sreg2;
  ins->sreg1 = D.30372;
  D.30373 = cfg->ip;
  ins->cil_code = D.30373;
  ins->dreg = dreg;
  D.30374 = cfg->gsharedvt_info_var;
  D.30375 = D.30374->dreg;
  ins->sreg1 = D.30375;
  D.30376 = (long unsigned int) idx;
  D.30377 = D.30376 + 1;
  D.30378 = D.30377 * 8;
  D.30379 = (long int) D.30378;
  ins->data.op[0].const_val = D.30379;
  ins->type = 1;
  D.30380 = cfg->cbb;
  D.30381 = D.30380->last_ins;
  if (D.30381 != 0B) goto <D.30382>; else goto <D.30383>;
  <D.30382>:
  D.30380 = cfg->cbb;
  D.30381 = D.30380->last_ins;
  D.30381->next = ins;
  D.30380 = cfg->cbb;
  D.30381 = D.30380->last_ins;
  ins->prev = D.30381;
  D.30380 = cfg->cbb;
  D.30380->last_ins = ins;
  goto <D.30384>;
  <D.30383>:
  D.30380 = cfg->cbb;
  D.30380 = cfg->cbb;
  D.30380->last_ins = ins;
  D.30381 = D.30380->last_ins;
  D.30380->code = D.30381;
  <D.30384>:
  D.30385 = ins;
  return D.30385;
}


get_gsharedvt_info_slot (struct MonoCompile * cfg, void * data, MonoRgctxInfoType rgctx_type)
{
  _Bool D.30387;
  long int D.30388;
  long int D.30389;
  struct GPtrArray * D.30392;
  void * * D.30393;
  long unsigned int D.30394;
  long unsigned int D.30395;
  void * * D.30396;
  <unnamed type> D.30397;
  void * D.30400;
  int D.30405;
  unsigned int i.43;
  unsigned int D.30407;
  struct MonoMemPool * D.30408;
  struct MonoGSharedVtMethodInfo * info;
  struct MonoRuntimeGenericContextInfoTemplate * template;
  int i;
  int idx;

  info = cfg->gsharedvt_info;
  D.30387 = info == 0B;
  D.30388 = (long int) D.30387;
  D.30389 = __builtin_expect (D.30388, 0);
  if (D.30389 != 0) goto <D.30390>; else goto <D.30391>;
  <D.30390>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3354, "info");
  <D.30391>:
  i = 0;
  goto <D.26156>;
  <D.26155>:
  {
    struct MonoRuntimeGenericContextInfoTemplate * otemplate;

    D.30392 = info->entries;
    D.30393 = D.30392->pdata;
    D.30394 = (long unsigned int) i;
    D.30395 = D.30394 * 8;
    D.30396 = D.30393 + D.30395;
    otemplate = *D.30396;
    D.30397 = otemplate->info_type;
    if (D.30397 == rgctx_type) goto <D.30398>; else goto <D.30399>;
    <D.30398>:
    D.30400 = otemplate->data;
    if (D.30400 == data) goto <D.30401>; else goto <D.30402>;
    <D.30401>:
    if (rgctx_type != 21) goto <D.30403>; else goto <D.30404>;
    <D.30403>:
    D.30405 = i;
    return D.30405;
    <D.30404>:
    <D.30402>:
    <D.30399>:
  }
  i = i + 1;
  <D.26156>:
  i.43 = (unsigned int) i;
  D.30392 = info->entries;
  D.30407 = D.30392->len;
  if (i.43 < D.30407) goto <D.26155>; else goto <D.26157>;
  <D.26157>:
  D.30408 = cfg->mempool;
  template = mono_mempool_alloc0 (D.30408, 24);
  template->info_type = rgctx_type;
  template->data = data;
  D.30392 = info->entries;
  D.30407 = D.30392->len;
  idx = (int) D.30407;
  D.30392 = info->entries;
  monoeg_g_ptr_array_add (D.30392, template);
  D.30405 = idx;
  return D.30405;
}


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

  D.30410 = cfg->generic_sharing_context;
  if (D.30410 != 0B) goto <D.30411>; else goto <D.30412>;
  <D.30411>:
  D.30413 = mono_class_check_context_used (klass);
  return D.30413;
  <D.30412>:
  D.30413 = 0;
  return D.30413;
}


mono_emit_wb_aware_memcpy (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * iargs, int size, int align)
{
  gboolean D.30419;
  struct MonoInst * * D.30424;
  struct MonoMemPool * D.30425;
  void * D.30426;
  struct MonoInst * D.30427;
  long int D.30428;
  struct MonoInst * D.30429;
  int D.30430;
  int D.30431;
  const unsigned char * D.30432;
  long int D.30433;
  unsigned int D.30434;
  int D.30435;
  struct MonoBasicBlock * D.30436;
  struct MonoInst * D.30437;
  struct MonoInst * D.30440;
  struct MonoInst * * D.30442;
  void * D.30443;
  struct MonoInst * D.30444;
  long int D.30445;
  struct MonoInst * D.30446;
  int D.30447;
  int D.30448;
  unsigned int need_wb.44;
  long int D.30450;
  unsigned int D.30451;
  int D.30452;
  struct MonoInst * D.30455;
  struct MonoInst * D.30457;
  struct MonoInst * * D.30458;
  struct MonoInst * D.30459;
  unsigned int D.30460;
  unsigned int D.30461;
  void * D.30462;
  long int D.30463;
  struct MonoInst * D.30464;
  int D.30465;
  int D.30466;
  long int D.30470;
  struct MonoInst * D.30471;
  int D.30472;
  int D.30473;
  long int D.30474;
  long int D.30478;
  struct MonoInst * D.30479;
  int D.30480;
  int D.30481;
  unsigned int D.30485;
  unsigned int need_wb.45;
  void * D.30491;
  long int D.30495;
  struct MonoInst * D.30496;
  int D.30497;
  int D.30498;
  long int D.30502;
  struct MonoInst * D.30503;
  int D.30504;
  int D.30505;
  long int D.30509;
  struct MonoInst * D.30510;
  int D.30511;
  int D.30512;
  long int D.30516;
  struct MonoInst * D.30517;
  int D.30518;
  int D.30519;
  long int D.30523;
  struct MonoInst * D.30524;
  int D.30525;
  int D.30526;
  long int D.30530;
  struct MonoInst * D.30531;
  int D.30532;
  int D.30533;
  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.30415>; else goto <D.30416>;
      <D.30415>:
      align = 4;
      <D.30416>:
      if (align <= 7) goto <D.30417>; else goto <D.30418>;
      <D.30417>:
      D.30419 = 0;
      return D.30419;
      <D.30418>:
      if (size > 256) goto <D.30420>; else goto <D.30421>;
      <D.30420>:
      D.30419 = 0;
      return D.30419;
      <D.30421>:
      create_write_barrier_bitmap (cfg, klass, &need_wb, 0);
      if (size > 40) goto <D.30422>; else goto <D.30423>;
      <D.30422>:
      size = size + 7;
      size = size & -8;
      D.30424 = iargs + 16;
      D.30425 = cfg->mempool;
      D.30426 = mono_mempool_alloc (D.30425, 80);
      *D.30424 = D.30426;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->data.op[1].const_val = 0;
      D.30428 = D.30427->data.op[1].const_val;
      D.30427->data.op[0].const_val = D.30428;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->prev = 0B;
      D.30429 = D.30427->prev;
      D.30427->next = D.30429;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->opcode = 362;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->flags = 0;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->type = 0;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->dreg = -1;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->sreg3 = -1;
      D.30430 = D.30427->sreg3;
      D.30427->sreg2 = D.30430;
      D.30431 = D.30427->sreg2;
      D.30427->sreg1 = D.30431;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30432 = cfg->ip;
      D.30427->cil_code = D.30432;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30433 = (long int) size;
      D.30427->data.op[0].const_val = D.30433;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30427->type = 1;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30434 = alloc_dreg (cfg, 1);
      D.30435 = (int) D.30434;
      D.30427->dreg = D.30435;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      if (D.30437 != 0B) goto <D.30438>; else goto <D.30439>;
      <D.30438>:
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30440 = MEM[(struct MonoInst * *)iargs + 16B];
      D.30437->next = D.30440;
      D.30424 = iargs + 16;
      D.30427 = *D.30424;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30427->prev = D.30437;
      D.30436 = cfg->cbb;
      D.30440 = MEM[(struct MonoInst * *)iargs + 16B];
      D.30436->last_ins = D.30440;
      goto <D.30441>;
      <D.30439>:
      D.30436 = cfg->cbb;
      D.30436 = cfg->cbb;
      D.30440 = MEM[(struct MonoInst * *)iargs + 16B];
      D.30436->last_ins = D.30440;
      D.30437 = D.30436->last_ins;
      D.30436->code = D.30437;
      <D.30441>:
      D.30442 = iargs + 24;
      D.30425 = cfg->mempool;
      D.30443 = mono_mempool_alloc (D.30425, 80);
      *D.30442 = D.30443;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->data.op[1].const_val = 0;
      D.30445 = D.30444->data.op[1].const_val;
      D.30444->data.op[0].const_val = D.30445;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->prev = 0B;
      D.30446 = D.30444->prev;
      D.30444->next = D.30446;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->opcode = 362;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->flags = 0;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->type = 0;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->dreg = -1;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->sreg3 = -1;
      D.30447 = D.30444->sreg3;
      D.30444->sreg2 = D.30447;
      D.30448 = D.30444->sreg2;
      D.30444->sreg1 = D.30448;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30432 = cfg->ip;
      D.30444->cil_code = D.30432;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      need_wb.44 = need_wb;
      D.30450 = (long int) need_wb.44;
      D.30444->data.op[0].const_val = D.30450;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30444->type = 1;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30451 = alloc_dreg (cfg, 1);
      D.30452 = (int) D.30451;
      D.30444->dreg = D.30452;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      if (D.30437 != 0B) goto <D.30453>; else goto <D.30454>;
      <D.30453>:
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30455 = MEM[(struct MonoInst * *)iargs + 24B];
      D.30437->next = D.30455;
      D.30442 = iargs + 24;
      D.30444 = *D.30442;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30444->prev = D.30437;
      D.30436 = cfg->cbb;
      D.30455 = MEM[(struct MonoInst * *)iargs + 24B];
      D.30436->last_ins = D.30455;
      goto <D.30456>;
      <D.30454>:
      D.30436 = cfg->cbb;
      D.30436 = cfg->cbb;
      D.30455 = MEM[(struct MonoInst * *)iargs + 24B];
      D.30436->last_ins = D.30455;
      D.30437 = D.30436->last_ins;
      D.30436->code = D.30437;
      <D.30456>:
      mono_emit_jit_icall (cfg, mono_gc_wbarrier_value_copy_bitmap, iargs);
      D.30419 = 1;
      return D.30419;
      <D.30423>:
      D.30457 = *iargs;
      destreg = D.30457->dreg;
      D.30458 = iargs + 8;
      D.30459 = *D.30458;
      srcreg = D.30459->dreg;
      offset = 0;
      D.30460 = alloc_preg (cfg);
      dest_ptr_reg = (int) D.30460;
      D.30461 = alloc_preg (cfg);
      tmp_reg = (int) D.30461;
      D.30425 = cfg->mempool;
      D.30462 = mono_mempool_alloc (D.30425, 80);
      *iargs = D.30462;
      D.30457 = *iargs;
      D.30457 = *iargs;
      D.30457->data.op[1].const_val = 0;
      D.30463 = D.30457->data.op[1].const_val;
      D.30457->data.op[0].const_val = D.30463;
      D.30457 = *iargs;
      D.30457 = *iargs;
      D.30457->prev = 0B;
      D.30464 = D.30457->prev;
      D.30457->next = D.30464;
      D.30457 = *iargs;
      D.30457->opcode = 424;
      D.30457 = *iargs;
      D.30457->flags = 0;
      D.30457 = *iargs;
      D.30457->type = 0;
      D.30457 = *iargs;
      D.30457->dreg = -1;
      D.30457 = *iargs;
      D.30457 = *iargs;
      D.30457 = *iargs;
      D.30457->sreg3 = -1;
      D.30465 = D.30457->sreg3;
      D.30457->sreg2 = D.30465;
      D.30466 = D.30457->sreg2;
      D.30457->sreg1 = D.30466;
      D.30457 = *iargs;
      D.30432 = cfg->ip;
      D.30457->cil_code = D.30432;
      D.30457 = *iargs;
      D.30457->dreg = dest_ptr_reg;
      D.30457 = *iargs;
      D.30457->sreg1 = destreg;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      if (D.30437 != 0B) goto <D.30467>; else goto <D.30468>;
      <D.30467>:
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30457 = *iargs;
      D.30437->next = D.30457;
      D.30457 = *iargs;
      D.30436 = cfg->cbb;
      D.30437 = D.30436->last_ins;
      D.30457->prev = D.30437;
      D.30436 = cfg->cbb;
      D.30457 = *iargs;
      D.30436->last_ins = D.30457;
      goto <D.30469>;
      <D.30468>:
      D.30436 = cfg->cbb;
      D.30436 = cfg->cbb;
      D.30457 = *iargs;
      D.30436->last_ins = D.30457;
      D.30437 = D.30436->last_ins;
      D.30436->code = D.30437;
      <D.30469>:
      goto <D.26005>;
      <D.26004>:
      {
        struct MonoInst * load_inst;

        D.30425 = cfg->mempool;
        load_inst = mono_mempool_alloc (D.30425, 80);
        load_inst->data.op[1].const_val = 0;
        D.30470 = load_inst->data.op[1].const_val;
        load_inst->data.op[0].const_val = D.30470;
        load_inst->prev = 0B;
        D.30471 = load_inst->prev;
        load_inst->next = D.30471;
        load_inst->opcode = 388;
        load_inst->flags = 0;
        load_inst->type = 0;
        load_inst->dreg = -1;
        load_inst->sreg3 = -1;
        D.30472 = load_inst->sreg3;
        load_inst->sreg2 = D.30472;
        D.30473 = load_inst->sreg2;
        load_inst->sreg1 = D.30473;
        D.30432 = cfg->ip;
        load_inst->cil_code = D.30432;
        load_inst->dreg = tmp_reg;
        load_inst->sreg1 = srcreg;
        D.30474 = (long int) offset;
        load_inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30475>; else goto <D.30476>;
        <D.30475>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = load_inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        load_inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = load_inst;
        goto <D.30477>;
        <D.30476>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = load_inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30477>:
        {
          struct MonoInst * inst;

          D.30425 = cfg->mempool;
          inst = mono_mempool_alloc (D.30425, 80);
          inst->data.op[1].const_val = 0;
          D.30478 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30478;
          inst->prev = 0B;
          D.30479 = inst->prev;
          inst->next = D.30479;
          inst->opcode = 378;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30480 = inst->sreg3;
          inst->sreg2 = D.30480;
          D.30481 = inst->sreg2;
          inst->sreg1 = D.30481;
          D.30432 = cfg->ip;
          inst->cil_code = D.30432;
          inst->sreg1 = tmp_reg;
          inst->dreg = dest_ptr_reg;
          inst->data.op[0].const_val = 0;
          D.30436 = cfg->cbb;
          D.30437 = D.30436->last_ins;
          if (D.30437 != 0B) goto <D.30482>; else goto <D.30483>;
          <D.30482>:
          D.30436 = cfg->cbb;
          D.30437 = D.30436->last_ins;
          D.30437->next = inst;
          D.30436 = cfg->cbb;
          D.30437 = D.30436->last_ins;
          inst->prev = D.30437;
          D.30436 = cfg->cbb;
          D.30436->last_ins = inst;
          goto <D.30484>;
          <D.30483>:
          D.30436 = cfg->cbb;
          D.30436 = cfg->cbb;
          D.30436->last_ins = inst;
          D.30437 = D.30436->last_ins;
          D.30436->code = D.30437;
          <D.30484>:
        }
        need_wb.44 = need_wb;
        D.30485 = need_wb.44 & 1;
        if (D.30485 != 0) goto <D.30486>; else goto <D.30487>;
        <D.30486>:
        D.30457 = *iargs;
        emit_write_barrier (cfg, D.30457, load_inst);
        <D.30487>:
        offset = offset + 8;
        size = size + -8;
        need_wb.44 = need_wb;
        need_wb.45 = need_wb.44 >> 1;
        need_wb = need_wb.45;
        if (size > 7) goto <D.30489>; else goto <D.30490>;
        <D.30489>:
        D.30425 = cfg->mempool;
        D.30491 = mono_mempool_alloc (D.30425, 80);
        *iargs = D.30491;
        D.30457 = *iargs;
        D.30457 = *iargs;
        D.30457->data.op[1].const_val = 0;
        D.30463 = D.30457->data.op[1].const_val;
        D.30457->data.op[0].const_val = D.30463;
        D.30457 = *iargs;
        D.30457 = *iargs;
        D.30457->prev = 0B;
        D.30464 = D.30457->prev;
        D.30457->next = D.30464;
        D.30457 = *iargs;
        D.30457->opcode = 538;
        D.30457 = *iargs;
        D.30457->flags = 0;
        D.30457 = *iargs;
        D.30457->type = 0;
        D.30457 = *iargs;
        D.30457->dreg = -1;
        D.30457 = *iargs;
        D.30457 = *iargs;
        D.30457 = *iargs;
        D.30457->sreg3 = -1;
        D.30465 = D.30457->sreg3;
        D.30457->sreg2 = D.30465;
        D.30466 = D.30457->sreg2;
        D.30457->sreg1 = D.30466;
        D.30457 = *iargs;
        D.30432 = cfg->ip;
        D.30457->cil_code = D.30432;
        D.30457 = *iargs;
        D.30457->dreg = dest_ptr_reg;
        D.30457 = *iargs;
        D.30457->sreg1 = dest_ptr_reg;
        D.30457 = *iargs;
        D.30457->data.op[1].const_val = 8;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30492>; else goto <D.30493>;
        <D.30492>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30457 = *iargs;
        D.30437->next = D.30457;
        D.30457 = *iargs;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30457->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30457 = *iargs;
        D.30436->last_ins = D.30457;
        goto <D.30494>;
        <D.30493>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30457 = *iargs;
        D.30436->last_ins = D.30457;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30494>:
        <D.30490>:
      }
      <D.26005>:
      if (size > 7) goto <D.26004>; else goto <D.26006>;
      <D.26006>:
      goto <D.26010>;
      <D.26009>:
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30495 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30495;
        inst->prev = 0B;
        D.30496 = inst->prev;
        inst->next = D.30496;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30497 = inst->sreg3;
        inst->sreg2 = D.30497;
        D.30498 = inst->sreg2;
        inst->sreg1 = D.30498;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30499>; else goto <D.30500>;
        <D.30499>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30501>;
        <D.30500>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30501>:
      }
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30502 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30502;
        inst->prev = 0B;
        D.30503 = inst->prev;
        inst->next = D.30503;
        inst->opcode = 377;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30504 = inst->sreg3;
        inst->sreg2 = D.30504;
        D.30505 = inst->sreg2;
        inst->sreg1 = D.30505;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30506>; else goto <D.30507>;
        <D.30506>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30508>;
        <D.30507>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30508>:
      }
      offset = offset + 4;
      size = size + -4;
      <D.26010>:
      if (size > 3) goto <D.26009>; else goto <D.26011>;
      <D.26011>:
      goto <D.26015>;
      <D.26014>:
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30509 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30509;
        inst->prev = 0B;
        D.30510 = inst->prev;
        inst->next = D.30510;
        inst->opcode = 391;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30511 = inst->sreg3;
        inst->sreg2 = D.30511;
        D.30512 = inst->sreg2;
        inst->sreg1 = D.30512;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30513>; else goto <D.30514>;
        <D.30513>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30515>;
        <D.30514>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30515>:
      }
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30516 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30516;
        inst->prev = 0B;
        D.30517 = inst->prev;
        inst->next = D.30517;
        inst->opcode = 376;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30518 = inst->sreg3;
        inst->sreg2 = D.30518;
        D.30519 = inst->sreg2;
        inst->sreg1 = D.30519;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30520>; else goto <D.30521>;
        <D.30520>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30522>;
        <D.30521>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30522>:
      }
      offset = offset + 2;
      size = size + -2;
      <D.26015>:
      if (size > 1) goto <D.26014>; else goto <D.26016>;
      <D.26016>:
      goto <D.26020>;
      <D.26019>:
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30523 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30523;
        inst->prev = 0B;
        D.30524 = inst->prev;
        inst->next = D.30524;
        inst->opcode = 389;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30525 = inst->sreg3;
        inst->sreg2 = D.30525;
        D.30526 = inst->sreg2;
        inst->sreg1 = D.30526;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30527>; else goto <D.30528>;
        <D.30527>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30529>;
        <D.30528>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30529>:
      }
      {
        struct MonoInst * inst;

        D.30425 = cfg->mempool;
        inst = mono_mempool_alloc (D.30425, 80);
        inst->data.op[1].const_val = 0;
        D.30530 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.30530;
        inst->prev = 0B;
        D.30531 = inst->prev;
        inst->next = D.30531;
        inst->opcode = 375;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.30532 = inst->sreg3;
        inst->sreg2 = D.30532;
        D.30533 = inst->sreg2;
        inst->sreg1 = D.30533;
        D.30432 = cfg->ip;
        inst->cil_code = D.30432;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.30474 = (long int) offset;
        inst->data.op[0].const_val = D.30474;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        if (D.30437 != 0B) goto <D.30534>; else goto <D.30535>;
        <D.30534>:
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        D.30437->next = inst;
        D.30436 = cfg->cbb;
        D.30437 = D.30436->last_ins;
        inst->prev = D.30437;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        goto <D.30536>;
        <D.30535>:
        D.30436 = cfg->cbb;
        D.30436 = cfg->cbb;
        D.30436->last_ins = inst;
        D.30437 = D.30436->last_ins;
        D.30436->code = D.30437;
        <D.30536>:
      }
      offset = offset + 1;
      size = size + -1;
      <D.26020>:
      if (size > 0) goto <D.26019>; else goto <D.26021>;
      <D.26021>:
      D.30419 = 1;
      return D.30419;
    }
  finally
    {
      need_wb = {CLOBBER};
    }
}


create_write_barrier_bitmap (struct MonoCompile * cfg, struct MonoClass * klass, unsigned int * wb_bitmap, int offset)
{
  struct MonoType * D.30539;
  short unsigned int D.30540;
  int D.30541;
  int D.30542;
  int iftmp.46;
  long unsigned int D.30546;
  long unsigned int D.30547;
  int D.30550;
  unsigned int D.30551;
  unsigned int D.30552;
  struct MonoType * D.30554;
  int D.30555;
  unsigned int foffset.47;
  unsigned int D.30559;
  _Bool D.30560;
  long int D.30561;
  long int D.30562;
  unsigned int D.30565;
  int D.30566;
  int D.30567;
  int D.30568;
  unsigned int D.30569;
  unsigned int D.30570;
  long unsigned int D.30572;
  long unsigned int D.30573;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.25961>;
      <D.25963>:
      {
        int foffset;

        D.30539 = field->type;
        D.30540 = D.30539->attrs;
        D.30541 = (int) D.30540;
        D.30542 = D.30541 & 16;
        if (D.30542 != 0) goto <D.30543>; else goto <D.30544>;
        <D.30543>:
        // predicted unlikely by continue predictor.
        goto <D.25961>;
        <D.30544>:
        D.30546 = BIT_FIELD_REF <*klass, 64, 256>;
        D.30547 = D.30546 & 8;
        if (D.30547 != 0) goto <D.30548>; else goto <D.30549>;
        <D.30548>:
        D.30550 = field->offset;
        D.30551 = (unsigned int) D.30550;
        D.30552 = D.30551 + 4294967280;
        iftmp.46 = (int) D.30552;
        goto <D.30553>;
        <D.30549>:
        iftmp.46 = field->offset;
        <D.30553>:
        foffset = iftmp.46;
        D.30554 = mono_field_get_type (field);
        D.30555 = mini_type_is_reference (cfg, D.30554);
        if (D.30555 != 0) goto <D.30556>; else goto <D.30557>;
        <D.30556>:
        foffset.47 = (unsigned int) foffset;
        D.30559 = foffset.47 & 7;
        D.30560 = D.30559 != 0;
        D.30561 = (long int) D.30560;
        D.30562 = __builtin_expect (D.30561, 0);
        if (D.30562 != 0) goto <D.30563>; else goto <D.30564>;
        <D.30563>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2886, "(foffset % SIZEOF_VOID_P) == 0");
        <D.30564>:
        D.30565 = *wb_bitmap;
        D.30566 = offset + foffset;
        D.30567 = D.30566 / 8;
        D.30568 = 1 << D.30567;
        D.30569 = (unsigned int) D.30568;
        D.30570 = D.30565 | D.30569;
        *wb_bitmap = D.30570;
        goto <D.30571>;
        <D.30557>:
        {
          struct MonoClass * field_class;

          D.30539 = field->type;
          field_class = mono_class_from_mono_type (D.30539);
          D.30572 = BIT_FIELD_REF <*field_class, 64, 256>;
          D.30573 = D.30572 & 134217728;
          if (D.30573 != 0) goto <D.30574>; else goto <D.30575>;
          <D.30574>:
          D.30566 = offset + foffset;
          create_write_barrier_bitmap (cfg, field_class, wb_bitmap, D.30566);
          <D.30575>:
        }
        <D.30571>:
      }
      <D.25961>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.25963>; else goto <D.25964>;
      <D.25964>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


emit_write_barrier (struct MonoCompile * cfg, struct MonoInst * ptr, struct MonoInst * value)
{
  long unsigned int D.30576;
  long unsigned int D.30577;
  long unsigned int D.30583;
  int nursery_shift_bits.48;
  struct MonoMemPool * D.30588;
  long int D.30589;
  struct MonoInst * D.30590;
  int D.30591;
  int D.30592;
  const unsigned char * D.30593;
  struct MonoInst * ptr.49;
  int D.30595;
  int D.30596;
  struct MonoBasicBlock * D.30597;
  struct MonoInst * D.30598;
  unsigned int D.30604;
  unsigned int D.30605;
  long int D.30606;
  struct MonoInst * D.30607;
  int D.30608;
  int D.30609;
  int card_table_shift_bits.50;
  long int D.30611;
  void * card_table_mask.51;
  long int D.30618;
  struct MonoInst * D.30619;
  int D.30620;
  int D.30621;
  long int card_table_mask.52;
  long int D.30628;
  struct MonoInst * D.30629;
  guint16 iftmp.53;
  int D.30634;
  int D.30635;
  long int D.30638;
  struct MonoInst * D.30639;
  int D.30640;
  int D.30641;
  int D.30642;
  unsigned int D.30644;
  int D.30645;
  long int D.30650;
  struct MonoInst * D.30651;
  int D.30652;
  int D.30653;
  long int D.30657;
  struct MonoInst * D.30658;
  int D.30659;
  int D.30660;
  long int D.30664;
  struct MonoInst * D.30665;
  int D.30666;
  int D.30667;
  long int D.30672;
  struct MonoInst * D.30673;
  int D.30674;
  int D.30675;
  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.30576 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30577 = D.30576 & 1152921504606846976;
      if (D.30577 == 0) goto <D.30578>; else goto <D.30579>;
      <D.30578>:
      return;
      <D.30579>:
      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.30582>; else goto <D.30580>;
      <D.30582>:
      D.30576 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30583 = D.30576 & 274877906944;
      if (D.30583 == 0) goto <D.30584>; else goto <D.30580>;
      <D.30584>:
      if (card_table != 0B) goto <D.30585>; else goto <D.30580>;
      <D.30585>:
      nursery_shift_bits.48 = nursery_shift_bits;
      if (nursery_shift_bits.48 > 0) goto <D.30587>; else goto <D.30580>;
      <D.30587>:
      {
        struct MonoInst * wbarrier;

        D.30588 = cfg->mempool;
        wbarrier = mono_mempool_alloc (D.30588, 80);
        wbarrier->data.op[1].const_val = 0;
        D.30589 = wbarrier->data.op[1].const_val;
        wbarrier->data.op[0].const_val = D.30589;
        wbarrier->prev = 0B;
        D.30590 = wbarrier->prev;
        wbarrier->next = D.30590;
        wbarrier->opcode = 790;
        wbarrier->flags = 0;
        wbarrier->type = 0;
        wbarrier->dreg = -1;
        wbarrier->sreg3 = -1;
        D.30591 = wbarrier->sreg3;
        wbarrier->sreg2 = D.30591;
        D.30592 = wbarrier->sreg2;
        wbarrier->sreg1 = D.30592;
        D.30593 = cfg->ip;
        wbarrier->cil_code = D.30593;
        ptr.49 = ptr;
        D.30595 = ptr.49->dreg;
        wbarrier->sreg1 = D.30595;
        D.30596 = value->dreg;
        wbarrier->sreg2 = D.30596;
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        if (D.30598 != 0B) goto <D.30599>; else goto <D.30600>;
        <D.30599>:
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        D.30598->next = wbarrier;
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        wbarrier->prev = D.30598;
        D.30597 = cfg->cbb;
        D.30597->last_ins = wbarrier;
        goto <D.30601>;
        <D.30600>:
        D.30597 = cfg->cbb;
        D.30597 = cfg->cbb;
        D.30597->last_ins = wbarrier;
        D.30598 = D.30597->last_ins;
        D.30597->code = D.30598;
        <D.30601>:
      }
      goto <D.30581>;
      <D.30580>:
      if (card_table != 0B) goto <D.30602>; else goto <D.30603>;
      <D.30602>:
      {
        int offset_reg;
        int card_reg;
        struct MonoInst * ins;

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

          D.30588 = cfg->mempool;
          inst = mono_mempool_alloc (D.30588, 80);
          inst->data.op[1].const_val = 0;
          D.30606 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30606;
          inst->prev = 0B;
          D.30607 = inst->prev;
          inst->next = D.30607;
          inst->opcode = 441;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30608 = inst->sreg3;
          inst->sreg2 = D.30608;
          D.30609 = inst->sreg2;
          inst->sreg1 = D.30609;
          D.30593 = cfg->ip;
          inst->cil_code = D.30593;
          inst->dreg = offset_reg;
          ptr.49 = ptr;
          D.30595 = ptr.49->dreg;
          inst->sreg1 = D.30595;
          card_table_shift_bits.50 = card_table_shift_bits;
          D.30611 = (long int) card_table_shift_bits.50;
          inst->data.op[1].const_val = D.30611;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          if (D.30598 != 0B) goto <D.30612>; else goto <D.30613>;
          <D.30612>:
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          D.30598->next = inst;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          inst->prev = D.30598;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          goto <D.30614>;
          <D.30613>:
          D.30597 = cfg->cbb;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          D.30598 = D.30597->last_ins;
          D.30597->code = D.30598;
          <D.30614>:
        }
        card_table_mask.51 = card_table_mask;
        if (card_table_mask.51 != 0B) goto <D.30616>; else goto <D.30617>;
        <D.30616>:
        {
          struct MonoInst * inst;

          D.30588 = cfg->mempool;
          inst = mono_mempool_alloc (D.30588, 80);
          inst->data.op[1].const_val = 0;
          D.30618 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30618;
          inst->prev = 0B;
          D.30619 = inst->prev;
          inst->next = D.30619;
          inst->opcode = 541;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30620 = inst->sreg3;
          inst->sreg2 = D.30620;
          D.30621 = inst->sreg2;
          inst->sreg1 = D.30621;
          D.30593 = cfg->ip;
          inst->cil_code = D.30593;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          card_table_mask.51 = card_table_mask;
          card_table_mask.52 = (long int) card_table_mask.51;
          inst->data.op[1].const_val = card_table_mask.52;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          if (D.30598 != 0B) goto <D.30623>; else goto <D.30624>;
          <D.30623>:
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          D.30598->next = inst;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          inst->prev = D.30598;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          goto <D.30625>;
          <D.30624>:
          D.30597 = cfg->cbb;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          D.30598 = D.30597->last_ins;
          D.30597->code = D.30598;
          <D.30625>:
        }
        <D.30617>:
        D.30576 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30583 = D.30576 & 274877906944;
        if (D.30583 != 0) goto <D.30626>; else goto <D.30627>;
        <D.30626>:
        {
          struct MonoInst * inst;

          D.30588 = cfg->mempool;
          inst = mono_mempool_alloc (D.30588, 80);
          inst->data.op[1].const_val = 0;
          D.30628 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30628;
          inst->prev = 0B;
          D.30629 = inst->prev;
          inst->next = D.30629;
          D.30576 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30583 = D.30576 & 274877906944;
          if (D.30583 != 0) goto <D.30631>; else goto <D.30632>;
          <D.30631>:
          iftmp.53 = 734;
          goto <D.30633>;
          <D.30632>:
          iftmp.53 = 363;
          <D.30633>:
          inst->opcode = iftmp.53;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30634 = inst->sreg3;
          inst->sreg2 = D.30634;
          D.30635 = inst->sreg2;
          inst->sreg1 = D.30635;
          D.30593 = cfg->ip;
          inst->cil_code = D.30593;
          D.30576 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30583 = D.30576 & 274877906944;
          if (D.30583 != 0) goto <D.30636>; else goto <D.30637>;
          <D.30636>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.30588 = cfg->mempool;
            group = mono_mempool_alloc (D.30588, 80);
            group->data.op[1].const_val = 0;
            D.30638 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.30638;
            group->prev = 0B;
            D.30639 = group->prev;
            group->next = D.30639;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.30640 = group->sreg3;
            group->sreg2 = D.30640;
            D.30641 = group->sreg2;
            group->sreg1 = D.30641;
            D.30593 = cfg->ip;
            group->cil_code = D.30593;
            group->data.op[0].src = 0B;
            group->data.op[1].src = 42B;
            D.30642 = got_loc->dreg;
            inst->sreg1 = D.30642;
            inst->data.op[1].p = group;
          }
          goto <D.30643>;
          <D.30637>:
          inst->data.op[0].p = 0B;
          inst->data.op[1].src = 42B;
          <D.30643>:
          inst->type = 3;
          D.30644 = alloc_dreg (cfg, 3);
          D.30645 = (int) D.30644;
          inst->dreg = D.30645;
          inst->dreg = card_reg;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          if (D.30598 != 0B) goto <D.30646>; else goto <D.30647>;
          <D.30646>:
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          D.30598->next = inst;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          inst->prev = D.30598;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          goto <D.30648>;
          <D.30647>:
          D.30597 = cfg->cbb;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          D.30598 = D.30597->last_ins;
          D.30597->code = D.30598;
          <D.30648>:
        }
        goto <D.30649>;
        <D.30627>:
        D.30588 = cfg->mempool;
        ins = mono_mempool_alloc (D.30588, 80);
        ins->data.op[1].const_val = 0;
        D.30650 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30650;
        ins->prev = 0B;
        D.30651 = ins->prev;
        ins->next = D.30651;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30652 = ins->sreg3;
        ins->sreg2 = D.30652;
        D.30653 = ins->sreg2;
        ins->sreg1 = D.30653;
        D.30593 = cfg->ip;
        ins->cil_code = D.30593;
        ins->data.op[0].p = card_table;
        ins->dreg = card_reg;
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        if (D.30598 != 0B) goto <D.30654>; else goto <D.30655>;
        <D.30654>:
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        D.30598->next = ins;
        D.30597 = cfg->cbb;
        D.30598 = D.30597->last_ins;
        ins->prev = D.30598;
        D.30597 = cfg->cbb;
        D.30597->last_ins = ins;
        goto <D.30656>;
        <D.30655>:
        D.30597 = cfg->cbb;
        D.30597 = cfg->cbb;
        D.30597->last_ins = ins;
        D.30598 = D.30597->last_ins;
        D.30597->code = D.30598;
        <D.30656>:
        <D.30649>:
        {
          struct MonoInst * inst;

          D.30588 = cfg->mempool;
          inst = mono_mempool_alloc (D.30588, 80);
          inst->data.op[1].const_val = 0;
          D.30657 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30657;
          inst->prev = 0B;
          D.30658 = inst->prev;
          inst->next = D.30658;
          inst->opcode = 479;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30659 = inst->sreg3;
          inst->sreg2 = D.30659;
          D.30660 = inst->sreg2;
          inst->sreg1 = D.30660;
          D.30593 = cfg->ip;
          inst->cil_code = D.30593;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          inst->sreg2 = card_reg;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          if (D.30598 != 0B) goto <D.30661>; else goto <D.30662>;
          <D.30661>:
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          D.30598->next = inst;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          inst->prev = D.30598;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          goto <D.30663>;
          <D.30662>:
          D.30597 = cfg->cbb;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          D.30598 = D.30597->last_ins;
          D.30597->code = D.30598;
          <D.30663>:
        }
        {
          struct MonoInst * inst;

          D.30588 = cfg->mempool;
          inst = mono_mempool_alloc (D.30588, 80);
          inst->data.op[1].const_val = 0;
          D.30664 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30664;
          inst->prev = 0B;
          D.30665 = inst->prev;
          inst->next = D.30665;
          inst->opcode = 382;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30666 = inst->sreg3;
          inst->sreg2 = D.30666;
          D.30667 = inst->sreg2;
          inst->sreg1 = D.30667;
          D.30593 = cfg->ip;
          inst->cil_code = D.30593;
          inst->dreg = offset_reg;
          inst->data.op[0].const_val = 0;
          inst->data.op[1].const_val = 1;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          if (D.30598 != 0B) goto <D.30668>; else goto <D.30669>;
          <D.30668>:
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          D.30598->next = inst;
          D.30597 = cfg->cbb;
          D.30598 = D.30597->last_ins;
          inst->prev = D.30598;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          goto <D.30670>;
          <D.30669>:
          D.30597 = cfg->cbb;
          D.30597 = cfg->cbb;
          D.30597->last_ins = inst;
          D.30598 = D.30597->last_ins;
          D.30597->code = D.30598;
          <D.30670>:
        }
      }
      goto <D.30671>;
      <D.30603>:
      {
        struct MonoMethod * write_barrier;

        write_barrier = mono_gc_get_write_barrier ();
        mono_emit_method_call (cfg, write_barrier, &ptr, 0B);
      }
      <D.30671>:
      <D.30581>:
      D.30588 = cfg->mempool;
      dummy_use = mono_mempool_alloc (D.30588, 80);
      dummy_use->data.op[1].const_val = 0;
      D.30672 = dummy_use->data.op[1].const_val;
      dummy_use->data.op[0].const_val = D.30672;
      dummy_use->prev = 0B;
      D.30673 = dummy_use->prev;
      dummy_use->next = D.30673;
      dummy_use->opcode = 796;
      dummy_use->flags = 0;
      dummy_use->type = 0;
      dummy_use->dreg = -1;
      dummy_use->sreg3 = -1;
      D.30674 = dummy_use->sreg3;
      dummy_use->sreg2 = D.30674;
      D.30675 = dummy_use->sreg2;
      dummy_use->sreg1 = D.30675;
      D.30593 = cfg->ip;
      dummy_use->cil_code = D.30593;
      D.30596 = value->dreg;
      dummy_use->sreg1 = D.30596;
      D.30597 = cfg->cbb;
      D.30598 = D.30597->last_ins;
      if (D.30598 != 0B) goto <D.30676>; else goto <D.30677>;
      <D.30676>:
      D.30597 = cfg->cbb;
      D.30598 = D.30597->last_ins;
      D.30598->next = dummy_use;
      D.30597 = cfg->cbb;
      D.30598 = D.30597->last_ins;
      dummy_use->prev = D.30598;
      D.30597 = cfg->cbb;
      D.30597->last_ins = dummy_use;
      goto <D.30678>;
      <D.30677>:
      D.30597 = cfg->cbb;
      D.30597 = cfg->cbb;
      D.30597->last_ins = dummy_use;
      D.30598 = D.30597->last_ins;
      D.30597->code = D.30598;
      <D.30678>:
    }
  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.30682;
  struct MonoMethod * D.30683;
  int D.30684;
  struct MonoInst * D.30685;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.30682 = cfg->mempool;
  D.30683 = cfg->current_method;
  D.30684 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.30682, D.30683, D.30684, 11, klass, rgctx_type);
  D.30683 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.30683, context_used);
  D.30685 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.30685;
}


get_memcpy_method ()
{
  struct MonoMethod * memcpy_method.54;
  struct MonoClass * D.30690;
  struct MonoMethod * memcpy_method.55;
  struct MonoMethod * D.30694;
  static struct MonoMethod * memcpy_method = 0B;

  memcpy_method.54 = memcpy_method;
  if (memcpy_method.54 == 0B) goto <D.30688>; else goto <D.30689>;
  <D.30688>:
  D.30690 = mono_defaults.string_class;
  memcpy_method.55 = mono_class_get_method_from_name (D.30690, "memcpy", 3);
  memcpy_method = memcpy_method.55;
  memcpy_method.54 = memcpy_method;
  if (memcpy_method.54 == 0B) goto <D.30692>; else goto <D.30693>;
  <D.30692>:
  monoeg_g_log (0B, 4, "Old corlib found. Install a new one");
  <D.25951>:
  goto <D.25951>;
  <D.30693>:
  <D.30689>:
  D.30694 = memcpy_method;
  return D.30694;
}


mini_emit_initobj (struct MonoCompile * cfg, struct MonoInst * dest, const guchar * ip, struct MonoClass * klass)
{
  int D.30696;
  struct MonoMethod * bzero_method.56;
  struct MonoClass * D.30702;
  struct MonoMethod * bzero_method.57;
  _Bool D.30704;
  long int D.30705;
  long int D.30706;
  struct MonoMethodSignature * D.30709;
  unsigned int n.58;
  int D.30713;
  unsigned int align.59;
  int align.60;
  struct MonoMemPool * D.30717;
  void * D.30718;
  struct MonoInst * D.30719;
  long int D.30720;
  struct MonoInst * D.30721;
  int D.30722;
  int D.30723;
  const unsigned char * D.30724;
  unsigned int D.30725;
  int D.30726;
  struct MonoBasicBlock * D.30727;
  struct MonoInst * D.30728;
  void * D.30732;
  struct MonoInst * D.30733;
  long int D.30734;
  struct MonoInst * D.30735;
  int D.30736;
  int D.30737;
  long int D.30738;
  unsigned int D.30739;
  int D.30740;
  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.30696 = mini_is_gsharedvt_klass (cfg, klass);
      if (D.30696 != 0) goto <D.30697>; else goto <D.30698>;
      <D.30697>:
      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.56 = bzero_method;
      if (bzero_method.56 == 0B) goto <D.30700>; else goto <D.30701>;
      <D.30700>:
      D.30702 = mono_defaults.string_class;
      bzero_method.57 = mono_class_get_method_from_name (D.30702, "bzero_aligned_1", 2);
      bzero_method = bzero_method.57;
      <D.30701>:
      bzero_method.56 = bzero_method;
      D.30704 = bzero_method.56 == 0B;
      D.30705 = (long int) D.30704;
      D.30706 = __builtin_expect (D.30705, 0);
      if (D.30706 != 0) goto <D.30707>; else goto <D.30708>;
      <D.30707>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3163, "bzero_method");
      <D.30708>:
      iargs[0] = dest;
      iargs[1] = size_ins;
      bzero_method.56 = bzero_method;
      D.30709 = mono_method_signature (bzero_method.56);
      mono_emit_calli (cfg, D.30709, &iargs, bzero_ins, 0B, 0B);
      return;
      <D.30698>:
      n = mono_class_value_size (klass, &align);
      n.58 = (unsigned int) n;
      if (n.58 <= 40) goto <D.30711>; else goto <D.30712>;
      <D.30711>:
      D.30713 = dest->dreg;
      align.59 = align;
      align.60 = (int) align.59;
      mini_emit_memset (cfg, D.30713, 0, n, 0, align.60);
      goto <D.30716>;
      <D.30712>:
      memset_method = get_memset_method ();
      iargs[0] = dest;
      D.30717 = cfg->mempool;
      D.30718 = mono_mempool_alloc (D.30717, 80);
      iargs[1] = D.30718;
      D.30719 = iargs[1];
      D.30719 = iargs[1];
      D.30719->data.op[1].const_val = 0;
      D.30720 = D.30719->data.op[1].const_val;
      D.30719->data.op[0].const_val = D.30720;
      D.30719 = iargs[1];
      D.30719 = iargs[1];
      D.30719->prev = 0B;
      D.30721 = D.30719->prev;
      D.30719->next = D.30721;
      D.30719 = iargs[1];
      D.30719->opcode = 362;
      D.30719 = iargs[1];
      D.30719->flags = 0;
      D.30719 = iargs[1];
      D.30719->type = 0;
      D.30719 = iargs[1];
      D.30719->dreg = -1;
      D.30719 = iargs[1];
      D.30719 = iargs[1];
      D.30719 = iargs[1];
      D.30719->sreg3 = -1;
      D.30722 = D.30719->sreg3;
      D.30719->sreg2 = D.30722;
      D.30723 = D.30719->sreg2;
      D.30719->sreg1 = D.30723;
      D.30719 = iargs[1];
      D.30724 = cfg->ip;
      D.30719->cil_code = D.30724;
      D.30719 = iargs[1];
      D.30719->data.op[0].const_val = 0;
      D.30719 = iargs[1];
      D.30719->type = 1;
      D.30719 = iargs[1];
      D.30725 = alloc_dreg (cfg, 1);
      D.30726 = (int) D.30725;
      D.30719->dreg = D.30726;
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      if (D.30728 != 0B) goto <D.30729>; else goto <D.30730>;
      <D.30729>:
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      D.30719 = iargs[1];
      D.30728->next = D.30719;
      D.30719 = iargs[1];
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      D.30719->prev = D.30728;
      D.30727 = cfg->cbb;
      D.30719 = iargs[1];
      D.30727->last_ins = D.30719;
      goto <D.30731>;
      <D.30730>:
      D.30727 = cfg->cbb;
      D.30727 = cfg->cbb;
      D.30719 = iargs[1];
      D.30727->last_ins = D.30719;
      D.30728 = D.30727->last_ins;
      D.30727->code = D.30728;
      <D.30731>:
      D.30717 = cfg->mempool;
      D.30732 = mono_mempool_alloc (D.30717, 80);
      iargs[2] = D.30732;
      D.30733 = iargs[2];
      D.30733 = iargs[2];
      D.30733->data.op[1].const_val = 0;
      D.30734 = D.30733->data.op[1].const_val;
      D.30733->data.op[0].const_val = D.30734;
      D.30733 = iargs[2];
      D.30733 = iargs[2];
      D.30733->prev = 0B;
      D.30735 = D.30733->prev;
      D.30733->next = D.30735;
      D.30733 = iargs[2];
      D.30733->opcode = 362;
      D.30733 = iargs[2];
      D.30733->flags = 0;
      D.30733 = iargs[2];
      D.30733->type = 0;
      D.30733 = iargs[2];
      D.30733->dreg = -1;
      D.30733 = iargs[2];
      D.30733 = iargs[2];
      D.30733 = iargs[2];
      D.30733->sreg3 = -1;
      D.30736 = D.30733->sreg3;
      D.30733->sreg2 = D.30736;
      D.30737 = D.30733->sreg2;
      D.30733->sreg1 = D.30737;
      D.30733 = iargs[2];
      D.30724 = cfg->ip;
      D.30733->cil_code = D.30724;
      D.30733 = iargs[2];
      D.30738 = (long int) n;
      D.30733->data.op[0].const_val = D.30738;
      D.30733 = iargs[2];
      D.30733->type = 1;
      D.30733 = iargs[2];
      D.30739 = alloc_dreg (cfg, 1);
      D.30740 = (int) D.30739;
      D.30733->dreg = D.30740;
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      if (D.30728 != 0B) goto <D.30741>; else goto <D.30742>;
      <D.30741>:
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      D.30733 = iargs[2];
      D.30728->next = D.30733;
      D.30733 = iargs[2];
      D.30727 = cfg->cbb;
      D.30728 = D.30727->last_ins;
      D.30733->prev = D.30728;
      D.30727 = cfg->cbb;
      D.30733 = iargs[2];
      D.30727->last_ins = D.30733;
      goto <D.30743>;
      <D.30742>:
      D.30727 = cfg->cbb;
      D.30727 = cfg->cbb;
      D.30733 = iargs[2];
      D.30727->last_ins = D.30733;
      D.30728 = D.30727->last_ins;
      D.30727->code = D.30728;
      <D.30743>:
      mono_emit_method_call (cfg, memset_method, &iargs, 0B);
      <D.30716>:
    }
  finally
    {
      iargs = {CLOBBER};
      align = {CLOBBER};
    }
}


mini_emit_memset (struct MonoCompile * cfg, int destreg, int offset, int size, int val, int align)
{
  _Bool D.30747;
  long int D.30748;
  long int D.30749;
  struct MonoMemPool * D.30758;
  long int D.30759;
  struct MonoInst * D.30760;
  int D.30761;
  int D.30762;
  const unsigned char * D.30763;
  long int D.30764;
  long int D.30765;
  struct MonoBasicBlock * D.30766;
  struct MonoInst * D.30767;
  long int D.30771;
  struct MonoInst * D.30772;
  int D.30773;
  int D.30774;
  long int D.30778;
  struct MonoInst * D.30779;
  int D.30780;
  int D.30781;
  long int D.30785;
  struct MonoInst * D.30786;
  int D.30787;
  int D.30788;
  unsigned int D.30793;
  long int D.30796;
  struct MonoInst * D.30797;
  int D.30798;
  int D.30799;
  long int D.30800;
  long int D.30805;
  struct MonoInst * D.30806;
  int D.30807;
  int D.30808;
  long int D.30809;
  long int D.30815;
  struct MonoInst * D.30816;
  int D.30817;
  int D.30818;
  unsigned int offset.61;
  unsigned int D.30825;
  long int D.30828;
  struct MonoInst * D.30829;
  int D.30830;
  int D.30831;
  long int D.30835;
  struct MonoInst * D.30836;
  int D.30837;
  int D.30838;
  long int D.30842;
  struct MonoInst * D.30843;
  int D.30844;
  int D.30845;
  long int D.30849;
  struct MonoInst * D.30850;
  int D.30851;
  int D.30852;
  long int D.30856;
  struct MonoInst * D.30857;
  int D.30858;
  int D.30859;
  int val_reg;

  D.30747 = val != 0;
  D.30748 = (long int) D.30747;
  D.30749 = __builtin_expect (D.30748, 0);
  if (D.30749 != 0) goto <D.30750>; else goto <D.30751>;
  <D.30750>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1744, "val == 0");
  <D.30751>:
  if (align == 0) goto <D.30752>; else goto <D.30753>;
  <D.30752>:
  align = 4;
  <D.30753>:
  if (size <= 4) goto <D.30754>; else goto <D.30755>;
  <D.30754>:
  if (size <= align) goto <D.30756>; else goto <D.30757>;
  <D.30756>:
  switch (size) <default: <D.30792>, case 1: <D.25546>, case 2: <D.25548>, case 4: <D.25550>, case 8: <D.25552>>
  <D.25546>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30759 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30759;
    inst->prev = 0B;
    D.30760 = inst->prev;
    inst->next = D.30760;
    inst->opcode = 382;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30761 = inst->sreg3;
    inst->sreg2 = D.30761;
    D.30762 = inst->sreg2;
    inst->sreg1 = D.30762;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30765 = (long int) val;
    inst->data.op[1].const_val = D.30765;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30768>; else goto <D.30769>;
    <D.30768>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30770>;
    <D.30769>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30770>:
  }
  return;
  <D.25548>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30771 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30771;
    inst->prev = 0B;
    D.30772 = inst->prev;
    inst->next = D.30772;
    inst->opcode = 383;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30773 = inst->sreg3;
    inst->sreg2 = D.30773;
    D.30774 = inst->sreg2;
    inst->sreg1 = D.30774;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30765 = (long int) val;
    inst->data.op[1].const_val = D.30765;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30775>; else goto <D.30776>;
    <D.30775>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30777>;
    <D.30776>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30777>:
  }
  return;
  <D.25550>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30778 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30778;
    inst->prev = 0B;
    D.30779 = inst->prev;
    inst->next = D.30779;
    inst->opcode = 384;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30780 = inst->sreg3;
    inst->sreg2 = D.30780;
    D.30781 = inst->sreg2;
    inst->sreg1 = D.30781;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30765 = (long int) val;
    inst->data.op[1].const_val = D.30765;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30782>; else goto <D.30783>;
    <D.30782>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30784>;
    <D.30783>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30784>:
  }
  return;
  <D.25552>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30785 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30785;
    inst->prev = 0B;
    D.30786 = inst->prev;
    inst->next = D.30786;
    inst->opcode = 385;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30787 = inst->sreg3;
    inst->sreg2 = D.30787;
    D.30788 = inst->sreg2;
    inst->sreg1 = D.30788;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30765 = (long int) val;
    inst->data.op[1].const_val = D.30765;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30789>; else goto <D.30790>;
    <D.30789>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30791>;
    <D.30790>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30791>:
  }
  return;
  <D.30792>:
  <D.30757>:
  <D.30755>:
  D.30793 = alloc_preg (cfg);
  val_reg = (int) D.30793;
  if (1 != 0) goto <D.30794>; else goto <D.30795>;
  <D.30794>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30796 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30796;
    inst->prev = 0B;
    D.30797 = inst->prev;
    inst->next = D.30797;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30798 = inst->sreg3;
    inst->sreg2 = D.30798;
    D.30799 = inst->sreg2;
    inst->sreg1 = D.30799;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = val_reg;
    D.30800 = (long int) val;
    inst->data.i8const = D.30800;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30801>; else goto <D.30802>;
    <D.30801>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30803>;
    <D.30802>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30803>:
  }
  goto <D.30804>;
  <D.30795>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30805 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30805;
    inst->prev = 0B;
    D.30806 = inst->prev;
    inst->next = D.30806;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30807 = inst->sreg3;
    inst->sreg2 = D.30807;
    D.30808 = inst->sreg2;
    inst->sreg1 = D.30808;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->dreg = val_reg;
    D.30809 = (long int) val;
    inst->data.op[0].const_val = D.30809;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30810>; else goto <D.30811>;
    <D.30810>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30812>;
    <D.30811>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30812>:
  }
  <D.30804>:
  if (align <= 3) goto <D.30813>; else goto <D.30814>;
  <D.30813>:
  goto <D.25558>;
  <D.25557>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30815 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30815;
    inst->prev = 0B;
    D.30816 = inst->prev;
    inst->next = D.30816;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30817 = inst->sreg3;
    inst->sreg2 = D.30817;
    D.30818 = inst->sreg2;
    inst->sreg1 = D.30818;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30819>; else goto <D.30820>;
    <D.30819>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30821>;
    <D.30820>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30821>:
  }
  offset = offset + 1;
  size = size + -1;
  <D.25558>:
  if (size > 0) goto <D.25557>; else goto <D.25559>;
  <D.25559>:
  return;
  <D.30814>:
  if (1 != 0) goto <D.30822>; else goto <D.30823>;
  <D.30822>:
  offset.61 = (unsigned int) offset;
  D.30825 = offset.61 & 7;
  if (D.30825 != 0) goto <D.30826>; else goto <D.30827>;
  <D.30826>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30828 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30828;
    inst->prev = 0B;
    D.30829 = inst->prev;
    inst->next = D.30829;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30830 = inst->sreg3;
    inst->sreg2 = D.30830;
    D.30831 = inst->sreg2;
    inst->sreg1 = D.30831;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30832>; else goto <D.30833>;
    <D.30832>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30834>;
    <D.30833>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30834>:
  }
  offset = offset + 4;
  size = size + -4;
  <D.30827>:
  goto <D.25563>;
  <D.25562>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30835 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30835;
    inst->prev = 0B;
    D.30836 = inst->prev;
    inst->next = D.30836;
    inst->opcode = 378;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30837 = inst->sreg3;
    inst->sreg2 = D.30837;
    D.30838 = inst->sreg2;
    inst->sreg1 = D.30838;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30839>; else goto <D.30840>;
    <D.30839>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30841>;
    <D.30840>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30841>:
  }
  offset = offset + 8;
  size = size + -8;
  <D.25563>:
  if (size > 7) goto <D.25562>; else goto <D.25564>;
  <D.25564>:
  <D.30823>:
  goto <D.25567>;
  <D.25566>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30842 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30842;
    inst->prev = 0B;
    D.30843 = inst->prev;
    inst->next = D.30843;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30844 = inst->sreg3;
    inst->sreg2 = D.30844;
    D.30845 = inst->sreg2;
    inst->sreg1 = D.30845;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30846>; else goto <D.30847>;
    <D.30846>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30848>;
    <D.30847>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30848>:
  }
  offset = offset + 4;
  size = size + -4;
  <D.25567>:
  if (size > 3) goto <D.25566>; else goto <D.25568>;
  <D.25568>:
  goto <D.25571>;
  <D.25570>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30849 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30849;
    inst->prev = 0B;
    D.30850 = inst->prev;
    inst->next = D.30850;
    inst->opcode = 376;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30851 = inst->sreg3;
    inst->sreg2 = D.30851;
    D.30852 = inst->sreg2;
    inst->sreg1 = D.30852;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30853>; else goto <D.30854>;
    <D.30853>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30855>;
    <D.30854>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30855>:
  }
  offset = offset + 2;
  size = size + -2;
  <D.25571>:
  if (size > 1) goto <D.25570>; else goto <D.25572>;
  <D.25572>:
  goto <D.25575>;
  <D.25574>:
  {
    struct MonoInst * inst;

    D.30758 = cfg->mempool;
    inst = mono_mempool_alloc (D.30758, 80);
    inst->data.op[1].const_val = 0;
    D.30856 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30856;
    inst->prev = 0B;
    D.30857 = inst->prev;
    inst->next = D.30857;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30858 = inst->sreg3;
    inst->sreg2 = D.30858;
    D.30859 = inst->sreg2;
    inst->sreg1 = D.30859;
    D.30763 = cfg->ip;
    inst->cil_code = D.30763;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30764 = (long int) offset;
    inst->data.op[0].const_val = D.30764;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    if (D.30767 != 0B) goto <D.30860>; else goto <D.30861>;
    <D.30860>:
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    D.30767->next = inst;
    D.30766 = cfg->cbb;
    D.30767 = D.30766->last_ins;
    inst->prev = D.30767;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    goto <D.30862>;
    <D.30861>:
    D.30766 = cfg->cbb;
    D.30766 = cfg->cbb;
    D.30766->last_ins = inst;
    D.30767 = D.30766->last_ins;
    D.30766->code = D.30767;
    <D.30862>:
  }
  offset = offset + 1;
  size = size + -1;
  <D.25575>:
  if (size > 0) goto <D.25574>; else goto <D.25576>;
  <D.25576>:
}


get_memset_method ()
{
  struct MonoMethod * memset_method.62;
  struct MonoClass * D.30867;
  struct MonoMethod * memset_method.63;
  struct MonoMethod * D.30871;
  static struct MonoMethod * memset_method = 0B;

  memset_method.62 = memset_method;
  if (memset_method.62 == 0B) goto <D.30865>; else goto <D.30866>;
  <D.30865>:
  D.30867 = mono_defaults.string_class;
  memset_method.63 = mono_class_get_method_from_name (D.30867, "memset", 3);
  memset_method = memset_method.63;
  memset_method.62 = memset_method;
  if (memset_method.62 == 0B) goto <D.30869>; else goto <D.30870>;
  <D.30869>:
  monoeg_g_log (0B, 4, "Old corlib found. Install a new one");
  <D.26043>:
  goto <D.26043>;
  <D.30870>:
  <D.30866>:
  D.30871 = memset_method;
  return D.30871;
}


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


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

  D.30876 = 0;
  return D.30876;
}


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.30878;
  struct MonoImage * D.30879;
  struct MonoAssembly * D.30880;
  unsigned char D.30881;
  _Bool D.30882;
  long unsigned int D.30883;
  long unsigned int D.30884;
  _Bool D.30885;
  int D.30886;
  _Bool D.30887;
  int D.30888;
  _Bool D.30889;
  int D.30890;
  _Bool D.30891;
  int D.30892;
  _Bool D.30893;
  int D.30894;
  <unnamed type> D.30895;
  _Bool D.30896;
  int D.30897;
  _Bool D.30898;
  int D.30899;
  _Bool D.30900;
  int D.30901;
  _Bool D.30902;
  int D.30903;
  unsigned char D.30908;
  int D.30909;
  struct MonoMethod * D.30911;
  const char * D.30912;
  gchar * D.30913;
  <unnamed-unsigned:1> D.30914;
  int D.30915;
  short unsigned int D.30916;
  int D.30917;
  int D.30918;
  unsigned int D.30919;
  sizetype D.30920;
  int D.30921;
  unsigned int D.30922;
  unsigned int D.30923;
  int D.30924;
  <unnamed-unsigned:1> D.30925;
  int iftmp.64;
  long unsigned int D.30929;
  long unsigned int D.30930;
  struct MonoMemPool * D.30941;
  unsigned int D.30942;
  void * D.30943;
  unsigned int D.30944;
  void * D.30945;
  int * il_offsets.65;
  long unsigned int D.30947;
  long unsigned int D.30948;
  int * D.30949;
  int D.30950;
  unsigned int D.30951;
  long unsigned int D.30954;
  long unsigned int D.30955;
  long unsigned int D.30956;
  int D.30957;
  long unsigned int D.30958;
  long unsigned int D.30959;
  int n_il_offsets.66;
  int * line_numbers.67;
  long unsigned int D.30962;
  long unsigned int D.30963;
  struct MonoDomain * D.30966;
  int D.30967;
  long unsigned int D.30970;
  long unsigned int D.30971;
  struct MonoGenericSharingContext * D.30977;
  long unsigned int D.30980;
  _Bool D.30981;
  long int D.30982;
  long int D.30983;
  short unsigned int D.30986;
  long unsigned int D.30991;
  _Bool D.30992;
  long int D.30993;
  long int D.30994;
  struct MonoGenericContext * D.30997;
  struct MonoGenericInst * D.30998;
  _Bool D.30999;
  long int D.31000;
  long int D.31001;
  struct MonoGenericContext * D.31006;
  struct MonoGenericInst * D.31007;
  _Bool D.31010;
  long int D.31011;
  long int D.31012;
  unsigned int D.31018;
  void * D.31019;
  int D.31020;
  unsigned int D.31021;
  char * D.31024;
  unsigned int D.31025;
  long unsigned int D.31026;
  struct MonoType * iftmp.68;
  long unsigned int D.31030;
  long unsigned int D.31031;
  int D.31035;
  long unsigned int D.31036;
  long unsigned int D.31037;
  struct MonoType * * D.31038;
  struct MonoType * D.31039;
  unsigned int D.31042;
  unsigned int D.31043;
  int D.31046;
  struct MonoProfileCoverageInfo * D.31047;
  unsigned int D.31048;
  unsigned int D.31049;
  unsigned int D.31050;
  int D.31051;
  unsigned int D.31052;
  unsigned int D.31053;
  int D.31054;
  unsigned int D.31055;
  unsigned int D.31056;
  _Bool D.31057;
  long int D.31058;
  long int D.31059;
  long unsigned int D.31062;
  long unsigned int D.31063;
  struct GHashTable * D.31066;
  struct GHashTable * D.31067;
  struct MonoExceptionClause * D.31068;
  long unsigned int D.31069;
  long unsigned int D.31070;
  struct MonoBasicBlock * * D.31071;
  unsigned int D.31072;
  sizetype D.31073;
  unsigned char * D.31074;
  long int D.31075;
  unsigned char * D.31076;
  long int D.31077;
  long int D.31078;
  long unsigned int D.31079;
  long unsigned int D.31080;
  struct MonoBasicBlock * * D.31081;
  const unsigned char * D.31087;
  const unsigned char * D.31088;
  int D.31089;
  struct MonoDebugOptions * D.31094;
  int D.31095;
  unsigned int D.31097;
  unsigned int D.31098;
  int D.31099;
  unsigned char * D.31100;
  long int D.31103;
  long int D.31104;
  long unsigned int D.31105;
  long unsigned int D.31106;
  struct MonoBasicBlock * * D.31107;
  unsigned int D.31108;
  int D.31109;
  int D.31110;
  unsigned int D.31111;
  unsigned int D.31112;
  unsigned int D.31113;
  unsigned int D.31114;
  sizetype D.31115;
  unsigned char * D.31116;
  long int D.31117;
  long int D.31118;
  long unsigned int D.31119;
  long unsigned int D.31120;
  struct MonoBasicBlock * * D.31121;
  const unsigned char * D.31127;
  struct MonoDebugOptions * D.31132;
  int D.31133;
  unsigned int D.31135;
  unsigned int D.31136;
  int D.31137;
  unsigned char * D.31138;
  long int D.31141;
  long int D.31142;
  long unsigned int D.31143;
  long unsigned int D.31144;
  struct MonoBasicBlock * * D.31145;
  unsigned int D.31146;
  unsigned int D.31147;
  unsigned char D.31150;
  unsigned int D.31153;
  unsigned int D.31156;
  long int D.31158;
  struct MonoInst * D.31159;
  int D.31160;
  int D.31161;
  const unsigned char * D.31162;
  struct MonoInst * D.31163;
  long int D.31171;
  unsigned int D.31177;
  void * D.31180;
  struct MonoInst * * D.31181;
  int D.31182;
  struct MonoInst * D.31183;
  long int D.31184;
  struct MonoInst * D.31185;
  int D.31186;
  int D.31187;
  struct MonoInst * D.31188;
  int D.31189;
  struct MonoBasicBlock * bblock.113;
  struct MonoInst * D.31191;
  unsigned int D.31197;
  sizetype D.31198;
  unsigned char * D.31199;
  long int D.31200;
  long int D.31201;
  long unsigned int D.31202;
  long unsigned int D.31203;
  struct MonoBasicBlock * * D.31204;
  const unsigned char * D.31210;
  struct MonoDebugOptions * D.31215;
  int D.31216;
  unsigned int D.31218;
  unsigned int D.31219;
  int D.31220;
  void * D.31223;
  struct MonoInst * D.31224;
  struct MonoClass * D.31230;
  int D.31235;
  short unsigned int D.31241;
  int D.31242;
  int D.31243;
  struct MonoGenericContext * D.31245;
  struct MonoGenericInst * D.31246;
  long int D.31248;
  struct MonoInst * D.31249;
  int D.31250;
  int D.31251;
  struct MonoInst * D.31252;
  int D.31253;
  <unnamed-unsigned:15> D.31257;
  int D.31258;
  long unsigned int D.31260;
  long unsigned int D.31261;
  void * bblock.69;
  struct MonoBasicBlock * bblock.70;
  unsigned int D.31264;
  unsigned int D.31265;
  int D.31266;
  unsigned char * D.31267;
  long int D.31270;
  long int D.31271;
  long unsigned int D.31272;
  long unsigned int D.31273;
  struct MonoBasicBlock * * D.31274;
  struct MonoInst * D.31279;
  <unnamed type> D.31283;
  int iftmp.71;
  unsigned char D.31290;
  int iftmp.72;
  short unsigned int D.31306;
  int D.31307;
  int D.31308;
  struct MonoClass * D.31312;
  int D.31313;
  struct MonoClass * D.31320;
  int D.31323;
  unsigned int D.31334;
  unsigned int D.31335;
  long unsigned int D.31336;
  long unsigned int D.31337;
  unsigned char D.31339;
  unsigned int D.31340;
  unsigned int D.31341;
  int D.31342;
  struct GPtrArray * D.31347;
  struct MonoClass * D.31348;
  struct MonoType * D.31349;
  int D.31350;
  long int D.31351;
  struct MonoInst * D.31352;
  int D.31353;
  int D.31354;
  int D.31355;
  int D.31356;
  unsigned int D.31360;
  long int D.31361;
  struct MonoInst * D.31362;
  int D.31363;
  int D.31364;
  int D.31368;
  unsigned int D.31372;
  unsigned int D.31373;
  int D.31378;
  int D.31379;
  char * D.31380;
  void * D.31385;
  struct MonoInst * D.31386;
  long int D.31387;
  struct MonoInst * D.31388;
  int D.31389;
  int D.31390;
  long int D.31391;
  struct MonoInst * D.31392;
  int D.31393;
  int D.31394;
  unsigned int D.31395;
  struct MonoJumpInfoToken * D.31396;
  int D.31397;
  unsigned int D.31398;
  int D.31399;
  void * D.31401;
  unsigned int D.31402;
  int D.31403;
  void * D.31407;
  struct MonoInst * D.31408;
  long int D.31409;
  struct MonoInst * D.31410;
  int D.31411;
  int D.31412;
  unsigned int D.31413;
  long int D.31414;
  unsigned int D.31415;
  int D.31416;
  struct MonoMethod * D.31420;
  char * D.31421;
  void * D.31426;
  long int D.31427;
  struct MonoInst * D.31428;
  int D.31429;
  int D.31430;
  unsigned int D.31431;
  struct MonoJumpInfoToken * D.31432;
  int D.31433;
  unsigned int D.31434;
  int D.31435;
  void * D.31437;
  unsigned int D.31438;
  int D.31439;
  void * D.31443;
  unsigned int D.31444;
  long int D.31445;
  unsigned int D.31446;
  int D.31447;
  char * D.31451;
  void * D.31456;
  long int D.31457;
  struct MonoInst * D.31458;
  int D.31459;
  int D.31460;
  unsigned int D.31461;
  struct MonoJumpInfoToken * D.31462;
  int D.31463;
  unsigned int D.31464;
  int D.31465;
  void * D.31467;
  unsigned int D.31468;
  int D.31469;
  void * D.31473;
  unsigned int D.31474;
  long int D.31475;
  unsigned int D.31476;
  int D.31477;
  struct MonoMethod * D.31481;
  struct MonoMethod * D.31484;
  <unnamed type> D.31485;
  short unsigned int D.31492;
  int D.31493;
  short unsigned int D.31494;
  int D.31495;
  int D.31496;
  int D.31503;
  struct MonoException * iftmp.73;
  unsigned int D.31510;
  struct MonoDebugOptions * D.31518;
  int D.31519;
  int D.31521;
  struct MonoDebugOptions * D.31528;
  int D.31529;
  unsigned int breakpoint_id.74;
  struct MonoType * D.31534;
  long unsigned int D.31535;
  long unsigned int D.31536;
  struct MonoDebugOptions * D.31543;
  int D.31544;
  short unsigned int D.31546;
  int D.31547;
  struct MonoGenericContext * D.31556;
  struct MonoGenericInst * D.31557;
  struct MonoInst * * D.31559;
  struct MonoInst * D.31560;
  unsigned char D.31561;
  unsigned char D.31562;
  long int D.31565;
  struct MonoInst * D.31566;
  int D.31567;
  int D.31568;
  struct MonoType * * D.31569;
  struct MonoType * D.31570;
  unsigned int D.31571;
  short unsigned int D.31572;
  struct MonoClass * D.31573;
  int D.31574;
  unsigned char D.31575;
  <unnamed type> D.31576;
  unsigned int D.31577;
  int D.31578;
  short unsigned int D.31579;
  struct MonoClass * D.31582;
  unsigned int D.31586;
  long unsigned int D.31587;
  long int D.31592;
  struct MonoInst * D.31593;
  int D.31594;
  int D.31595;
  int D.31596;
  long int D.31600;
  struct MonoInst * D.31601;
  int D.31602;
  int D.31603;
  long int D.31609;
  struct MonoInst * D.31610;
  int D.31611;
  int D.31612;
  long int D.31616;
  struct MonoInst * D.31617;
  int D.31618;
  int D.31619;
  _Bool D.31623;
  int D.31626;
  struct MonoDebugOptions * D.31633;
  int D.31634;
  _Bool D.31636;
  long int D.31637;
  long int D.31638;
  <unnamed-unsigned:15> D.31641;
  int D.31642;
  int D.31643;
  long unsigned int D.31644;
  unsigned int D.31645;
  unsigned int D.31646;
  long int ip.75;
  long int D.31650;
  long int D.31651;
  unsigned int D.31652;
  long int D.31656;
  int D.31657;
  _Bool D.31660;
  long int D.31661;
  long int D.31662;
  long int D.31666;
  long unsigned int D.31667;
  long unsigned int D.31668;
  struct MonoBasicBlock * * D.31669;
  struct MonoDebugOptions * D.31679;
  int D.31680;
  unsigned int D.31682;
  unsigned int D.31683;
  int D.31684;
  struct MonoInst * * D.31689;
  long unsigned int D.31690;
  struct MonoInst * * D.31691;
  struct MonoInst * D.31692;
  long int D.31693;
  int D.31694;
  struct MonoInst * * D.31695;
  long unsigned int D.31696;
  long unsigned int D.31697;
  struct MonoInst * * D.31698;
  struct MonoInst * D.31699;
  struct MonoType * D.31700;
  unsigned int D.31701;
  short unsigned int D.31702;
  struct MonoClass * D.31703;
  int D.31704;
  unsigned char D.31705;
  <unnamed type> D.31706;
  unsigned int D.31707;
  int D.31708;
  short unsigned int D.31709;
  struct MonoClass * D.31712;
  struct MonoInst * * sp.76;
  short unsigned int D.31717;
  int D.31718;
  long int sp.77;
  long int stack_start.78;
  long int D.31730;
  long int D.31731;
  int D.31732;
  long unsigned int D.31733;
  struct MonoDebugOptions * D.31740;
  int D.31741;
  unsigned int D.31745;
  short unsigned int D.31746;
  unsigned int D.31747;
  int D.31748;
  struct MonoClass * D.31751;
  struct MonoInst * * sp.79;
  int D.31758;
  long unsigned int D.31761;
  long unsigned int D.31762;
  _Bool D.31765;
  long int D.31766;
  long int D.31767;
  int D.31772;
  sizetype D.31778;
  long unsigned int D.31785;
  long unsigned int D.31786;
  long unsigned int D.31787;
  int D.31788;
  int D.31789;
  long unsigned int D.31790;
  long unsigned int D.31791;
  int iftmp.80;
  struct MonoMethodHeader * D.31798;
  long unsigned int D.31799;
  long unsigned int D.31800;
  _Bool D.31801;
  unsigned char D.31802;
  unsigned char D.31805;
  unsigned char D.31806;
  long unsigned int D.31812;
  long unsigned int D.31813;
  long unsigned int D.31814;
  long unsigned int D.31815;
  struct MonoProfileCoverageInfo * D.31818;
  int * D.31821;
  unsigned int D.31822;
  int D.31823;
  long int D.31827;
  struct MonoInst * D.31828;
  int D.31829;
  int D.31830;
  int D.31836;
  char * D.31837;
  unsigned char D.31838;
  int D.31839;
  long unsigned int D.31849;
  int D.31856;
  long int D.31863;
  struct MonoDebugOptions * D.31870;
  int D.31871;
  unsigned int n.81;
  struct MonoDebugOptions * D.31880;
  int D.31881;
  long unsigned int D.31883;
  long unsigned int D.31884;
  struct MonoType * * D.31885;
  struct MonoType * D.31886;
  unsigned int D.31887;
  short unsigned int D.31888;
  struct MonoInst * * D.31889;
  struct MonoInst * D.31890;
  struct MonoClass * D.31891;
  int D.31892;
  unsigned int D.31893;
  int D.31894;
  struct MonoClass * D.31897;
  struct MonoInst * * sp.82;
  struct MonoDebugOptions * D.31908;
  int D.31909;
  unsigned int D.31911;
  struct MonoDebugOptions * D.31918;
  int D.31919;
  unsigned int D.31921;
  short unsigned int D.31922;
  struct MonoInst * * D.31923;
  struct MonoInst * * D.31924;
  struct MonoInst * D.31925;
  struct MonoClass * D.31926;
  int D.31927;
  unsigned int D.31928;
  int D.31929;
  struct MonoClass * D.31932;
  struct MonoInst * * sp.83;
  struct MonoDebugOptions * D.31943;
  int D.31944;
  struct MonoDebugOptions * D.31952;
  int D.31953;
  struct MonoInst * D.31957;
  int D.31958;
  struct MonoDebugOptions * D.31965;
  int D.31966;
  unsigned char * D.31968;
  struct MonoDebugOptions * D.31975;
  int D.31976;
  struct MonoDebugOptions * D.31984;
  int D.31985;
  unsigned char * D.31987;
  unsigned char D.31988;
  struct MonoDebugOptions * D.31995;
  int D.31996;
  unsigned int D.31998;
  short unsigned int D.31999;
  unsigned int D.32000;
  int D.32001;
  struct MonoClass * D.32004;
  struct MonoInst * * sp.84;
  struct MonoDebugOptions * D.32015;
  int D.32016;
  struct MonoDebugOptions * D.32024;
  int D.32025;
  struct MonoDebugOptions * D.32033;
  int D.32034;
  struct MonoInst * * D.32036;
  struct MonoInst * D.32037;
  unsigned char D.32038;
  unsigned char D.32039;
  struct MonoClass * D.32040;
  unsigned int D.32041;
  int D.32042;
  _Bool D.32043;
  long int D.32044;
  long int D.32045;
  struct MonoType * D.32048;
  int D.32049;
  struct MonoInst * iftmp.85;
  int D.32055;
  int D.32056;
  unsigned int D.32057;
  unsigned int D.32058;
  struct MonoInst * * D.32061;
  sizetype D.32062;
  sizetype D.32063;
  sizetype D.32064;
  struct MonoInst * * D.32065;
  struct MonoInst * iftmp.86;
  int D.32068;
  unsigned int D.32069;
  sizetype D.32072;
  sizetype D.32073;
  struct MonoInst * * D.32074;
  _Bool D.32076;
  long int D.32077;
  long int D.32078;
  _Bool D.32081;
  long int D.32082;
  long int D.32083;
  unsigned char D.32086;
  unsigned char D.32087;
  unsigned char D.32088;
  unsigned char D.32089;
  struct MonoInst * * sp.87;
  struct MonoDebugOptions * D.32100;
  int D.32101;
  struct MonoDebugOptions * D.32109;
  int D.32110;
  struct MonoDebugOptions * D.32118;
  int D.32119;
  long unsigned int D.32123;
  long unsigned int D.32124;
  struct MonoType * * D.32125;
  struct MonoType * D.32126;
  int D.32127;
  struct MonoDebugOptions * D.32134;
  int D.32135;
  unsigned int D.32137;
  short unsigned int D.32138;
  int D.32139;
  struct MonoClass * D.32142;
  struct MonoDebugOptions * D.32152;
  int D.32153;
  struct MonoDebugOptions * D.32161;
  int D.32162;
  struct MonoDebugOptions * D.32170;
  int D.32171;
  unsigned int D.32173;
  short unsigned int D.32174;
  unsigned int D.32175;
  int D.32176;
  struct MonoClass * D.32179;
  struct MonoInst * * sp.88;
  struct MonoDebugOptions * D.32190;
  int D.32191;
  struct MonoDebugOptions * D.32199;
  int D.32200;
  short unsigned int D.32202;
  struct MonoDebugOptions * D.32209;
  int D.32210;
  struct MonoInst * * D.32214;
  struct MonoInst * D.32215;
  unsigned char D.32216;
  unsigned char D.32217;
  struct MonoClass * D.32218;
  unsigned int D.32219;
  int D.32220;
  struct MonoType * D.32223;
  int D.32224;
  struct MonoInst * iftmp.89;
  int D.32230;
  int D.32231;
  unsigned int D.32232;
  sizetype D.32235;
  sizetype D.32236;
  sizetype D.32237;
  struct MonoInst * * D.32238;
  struct MonoInst * iftmp.90;
  int D.32241;
  unsigned int D.32242;
  sizetype D.32245;
  sizetype D.32246;
  struct MonoInst * * D.32247;
  _Bool D.32249;
  long int D.32250;
  long int D.32251;
  _Bool D.32254;
  long int D.32255;
  long int D.32256;
  unsigned char D.32259;
  unsigned char D.32260;
  unsigned char D.32261;
  unsigned char D.32262;
  struct MonoInst * * sp.91;
  struct MonoDebugOptions * D.32273;
  int D.32274;
  struct MonoDebugOptions * D.32282;
  int D.32283;
  struct MonoDebugOptions * D.32291;
  int D.32292;
  int D.32296;
  struct MonoType * D.32297;
  int D.32298;
  struct MonoDebugOptions * D.32305;
  int D.32306;
  struct MonoDebugOptions * D.32314;
  int D.32315;
  unsigned int D.32317;
  int D.32318;
  struct MonoInst * * sp.92;
  struct MonoDebugOptions * D.32329;
  int D.32330;
  unsigned int D.32332;
  int D.32333;
  struct MonoInst * * sp.93;
  struct MonoDebugOptions * D.32344;
  int D.32345;
  int D.32347;
  long int D.32348;
  unsigned int D.32349;
  int D.32350;
  struct MonoInst * * sp.94;
  struct MonoDebugOptions * D.32361;
  int D.32362;
  struct MonoDebugOptions * D.32370;
  int D.32371;
  signed char D.32373;
  long int D.32374;
  unsigned int D.32375;
  int D.32376;
  struct MonoInst * * sp.95;
  unsigned char * D.32381;
  struct MonoDebugOptions * D.32388;
  int D.32389;
  struct MonoDebugOptions * D.32397;
  int D.32398;
  const guint32 * D.32400;
  unsigned int D.32401;
  int D.32402;
  long int D.32403;
  unsigned int D.32404;
  int D.32405;
  struct MonoInst * * sp.96;
  unsigned char * D.32410;
  struct MonoDebugOptions * D.32417;
  int D.32418;
  struct MonoDebugOptions * D.32426;
  int D.32427;
  unsigned int D.32429;
  int D.32430;
  long unsigned int D.32431;
  long int D.32432;
  struct MonoInst * * sp.97;
  struct MonoDebugOptions * D.32445;
  int D.32446;
  struct MonoDebugOptions * D.32454;
  int D.32455;
  long int D.32459;
  struct MonoInst * D.32460;
  guint16 iftmp.98;
  int D.32465;
  int D.32466;
  long int D.32469;
  struct MonoInst * D.32470;
  int D.32471;
  int D.32472;
  int D.32473;
  unsigned int D.32475;
  int D.32476;
  unsigned int D.32480;
  int D.32481;
  unsigned int D.32486;
  int D.32487;
  unsigned int D.32491;
  float D.32492;
  struct MonoInst * * sp.99;
  struct MonoDebugOptions * D.32502;
  int D.32503;
  struct MonoDebugOptions * D.32511;
  int D.32512;
  long int D.32516;
  struct MonoInst * D.32517;
  guint16 iftmp.100;
  int D.32522;
  int D.32523;
  long int D.32526;
  struct MonoInst * D.32527;
  int D.32528;
  int D.32529;
  int D.32530;
  unsigned int D.32532;
  int D.32533;
  unsigned int D.32537;
  int D.32538;
  unsigned int D.32543;
  int D.32544;
  double D.32548;
  struct MonoInst * * sp.101;
  struct MonoDebugOptions * D.32556;
  int D.32557;
  struct MonoDebugOptions * D.32565;
  int D.32566;
  struct MonoType * D.32568;
  long int D.32569;
  struct MonoInst * D.32570;
  int D.32571;
  int D.32572;
  long int D.32573;
  long unsigned int D.32574;
  long unsigned int D.32575;
  struct MonoInst * * D.32576;
  struct MonoInst * D.32577;
  struct MonoType * D.32578;
  unsigned int D.32579;
  short unsigned int D.32580;
  struct MonoClass * D.32581;
  int D.32582;
  short unsigned int D.32583;
  struct MonoClass * D.32586;
  unsigned int D.32590;
  short unsigned int D.32591;
  unsigned int D.32592;
  int D.32593;
  struct MonoClass * D.32596;
  struct MonoInst * * sp.102;
  unsigned int D.32601;
  short unsigned int D.32602;
  unsigned int D.32603;
  int D.32604;
  struct MonoClass * D.32607;
  struct MonoInst * * sp.103;
  struct MonoDebugOptions * D.32618;
  int D.32619;
  const char * D.32629;
  const char * D.32630;
  const char * D.32631;
  struct MonoMethodSignature * D.32632;
  short unsigned int D.32633;
  int D.32634;
  const char * D.32635;
  gchar * D.32636;
  char * D.32639;
  struct MonoDebugOptions * D.32646;
  int D.32647;
  struct MonoDebugOptions * D.32655;
  int D.32656;
  struct MonoLoaderError * D.32661;
  struct MonoDebugOptions * D.32662;
  int D.32663;
  int D.32667;
  const char * D.32674;
  <unnamed type> D.32675;
  short unsigned int D.32681;
  int D.32682;
  <unnamed-unsigned:1> D.32683;
  int D.32684;
  int D.32687;
  int D.32688;
  struct MonoMethodSignature * D.32689;
  long unsigned int D.32690;
  unsigned int D.32691;
  unsigned int D.32692;
  void * D.32693;
  struct MonoInst * * D.32694;
  long unsigned int D.32695;
  long unsigned int D.32696;
  struct MonoInst * * D.32697;
  void * D.32698;
  struct MonoInst * D.32699;
  long int D.32700;
  struct MonoInst * D.32701;
  int D.32702;
  int D.32703;
  struct MonoType * * D.32704;
  struct MonoType * D.32705;
  unsigned int D.32706;
  short unsigned int D.32707;
  struct MonoInst * * D.32708;
  struct MonoInst * D.32709;
  struct MonoClass * D.32710;
  int D.32711;
  unsigned char D.32712;
  <unnamed type> D.32713;
  unsigned int D.32714;
  int D.32715;
  short unsigned int D.32716;
  struct MonoClass * D.32719;
  struct MonoInst * * D.32727;
  struct MonoInst * D.32728;
  unsigned char D.32729;
  unsigned char D.32730;
  unsigned int i.104;
  _Bool D.32735;
  _Bool D.32736;
  struct MonoDebugOptions * D.32743;
  int D.32744;
  struct MonoDebugOptions * D.32754;
  int D.32755;
  short unsigned int D.32757;
  int D.32758;
  <unnamed-unsigned:1> D.32759;
  int D.32760;
  long unsigned int D.32761;
  long unsigned int D.32764;
  long unsigned int D.32765;
  void * D.32768;
  struct MonoInst * D.32769;
  long int D.32770;
  struct MonoInst * D.32771;
  guint16 iftmp.105;
  int D.32776;
  int D.32777;
  long int D.32780;
  struct MonoInst * D.32781;
  int D.32782;
  int D.32783;
  int D.32784;
  unsigned int D.32786;
  int D.32787;
  void * D.32791;
  struct MonoInst * D.32792;
  long int D.32793;
  struct MonoInst * D.32794;
  int D.32795;
  int D.32796;
  unsigned int D.32797;
  int D.32798;
  char * D.32809;
  unsigned char D.32813;
  struct MonoMethod * cil_method.106;
  char * D.32819;
  int D.32825;
  struct MonoClass * D.32828;
  long unsigned int D.32829;
  long unsigned int D.32830;
  _Bool D.32831;
  long int D.32832;
  long int D.32833;
  struct MonoLoaderError * D.32839;
  struct MonoDebugOptions * D.32840;
  int D.32841;
  long unsigned int D.32845;
  struct MonoGenericContainer * D.32850;
  struct MonoGenericContext * D.32851;
  int D.32852;
  int D.32855;
  gchar * D.32858;
  <unnamed type> D.32859;
  short unsigned int D.32864;
  int D.32865;
  int D.32866;
  long unsigned int D.32871;
  int D.32874;
  long unsigned int D.32877;
  long unsigned int D.32878;
  long unsigned int D.32881;
  int D.32884;
  struct MonoDebugOptions * D.32887;
  int D.32888;
  short unsigned int D.32894;
  int D.32895;
  int D.32896;
  int D.32898;
  unsigned char D.32900;
  struct MonoDebugOptions * D.32903;
  int D.32904;
  int check_for_pending_exc.107;
  <unnamed-unsigned:1> D.32909;
  int D.32910;
  struct MonoType * D.32915;
  int D.32916;
  unsigned char D.32923;
  long int D.32926;
  long int D.32927;
  long unsigned int D.32928;
  long unsigned int D.32929;
  long unsigned int D.32930;
  int D.32931;
  int D.32932;
  long unsigned int D.32933;
  long unsigned int D.32934;
  <unnamed type> D.32935;
  int D.32938;
  long unsigned int D.32948;
  long unsigned int D.32949;
  struct MonoGenericContainer * D.32958;
  struct MonoDebugOptions * D.32965;
  int D.32966;
  int D.32972;
  _Bool D.32973;
  long int D.32974;
  long int D.32975;
  long int D.32978;
  struct MonoDebugOptions * D.32985;
  int D.32986;
  sizetype D.32988;
  int D.32991;
  struct MonoClass * D.32996;
  long unsigned int D.32998;
  long unsigned int D.32999;
  struct MonoImage * D.33004;
  struct MonoImage * D.33005;
  unsigned int D.33007;
  unsigned int D.33008;
  int D.33019;
  long unsigned int D.33021;
  long unsigned int D.33022;
  unsigned char D.33024;
  unsigned char D.33025;
  unsigned char D.33027;
  int D.33028;
  int D.33030;
  long unsigned int D.33032;
  struct MonoType * D.33035;
  int D.33036;
  int D.33038;
  int D.33039;
  int D.33042;
  struct MonoInst * D.33043;
  void * D.33045;
  struct MonoInst * D.33046;
  long int D.33047;
  struct MonoInst * D.33048;
  guint16 iftmp.108;
  int D.33053;
  int D.33054;
  long int D.33057;
  struct MonoInst * D.33058;
  int D.33059;
  int D.33060;
  int D.33061;
  unsigned int D.33063;
  int D.33064;
  int D.33068;
  struct MonoInst * D.33069;
  long unsigned int D.33072;
  unsigned int D.33075;
  int D.33076;
  long unsigned int D.33077;
  long unsigned int D.33078;
  long int D.33079;
  int D.33083;
  struct MonoClass * D.33086;
  struct MonoInst * D.33087;
  struct MonoInst * iftmp.109;
  struct MonoInst * * D.33089;
  struct MonoInst * D.33090;
  int D.33091;
  unsigned int D.33092;
  long unsigned int D.33095;
  long unsigned int D.33096;
  struct MonoInst * * D.33097;
  unsigned char D.33101;
  unsigned char D.33102;
  struct MonoClass * D.33103;
  unsigned int D.33104;
  int D.33105;
  struct MonoType * D.33108;
  int D.33109;
  struct MonoInst * iftmp.110;
  int D.33115;
  int D.33116;
  unsigned int D.33117;
  sizetype D.33120;
  sizetype D.33121;
  sizetype D.33122;
  struct MonoInst * * D.33123;
  struct MonoInst * iftmp.111;
  int D.33126;
  unsigned int D.33127;
  sizetype D.33130;
  sizetype D.33131;
  struct MonoInst * * D.33132;
  _Bool D.33134;
  long int D.33135;
  long int D.33136;
  _Bool D.33139;
  long int D.33140;
  long int D.33141;
  unsigned char D.33144;
  unsigned char D.33145;
  unsigned char D.33146;
  unsigned char D.33147;
  struct MonoInst * D.33151;
  int D.33152;
  void * D.33157;
  struct MonoInst * D.33158;
  long int D.33159;
  struct MonoInst * D.33160;
  int D.33161;
  int D.33162;
  unsigned int D.33163;
  int D.33164;
  void * D.33171;
  unsigned int D.33172;
  int D.33173;
  void * D.33177;
  long int D.33178;
  struct MonoInst * D.33179;
  int D.33180;
  int D.33181;
  unsigned int D.33182;
  int D.33183;
  int D.33187;
  struct MonoClass * D.33190;
  long int D.33197;
  struct MonoInst * D.33198;
  int D.33199;
  int D.33200;
  unsigned int D.33201;
  int D.33202;
  unsigned int D.33206;
  short unsigned int D.33207;
  int D.33208;
  unsigned int D.33209;
  int D.33210;
  const char * D.33216;
  gchar * D.33217;
  struct MonoClass * D.33225;
  struct MonoClass * D.33226;
  struct MonoType * D.33228;
  unsigned int D.33229;
  short unsigned int D.33230;
  unsigned int D.33231;
  int D.33232;
  int D.33236;
  struct MonoInst * D.33237;
  unsigned int D.33241;
  unsigned char D.33252;
  struct MonoDebugOptions * D.33253;
  int D.33254;
  struct MonoDebugOptions * D.33258;
  int D.33259;
  struct MonoDebugOptions * D.33265;
  int D.33266;
  struct MonoMethod * * D.33270;
  int D.33271;
  long unsigned int D.33272;
  long unsigned int D.33273;
  struct MonoMethod * * D.33274;
  unsigned int D.33277;
  short unsigned int D.33278;
  unsigned int D.33279;
  int D.33280;
  int D.33284;
  struct MonoInst * D.33285;
  int D.33289;
  struct MonoDebugOptions * D.33296;
  int D.33297;
  struct MonoClass * D.33301;
  struct MonoClass * D.33302;
  int D.27982;
  int iftmp.112;
  int D.27981;
  const char[7] * D.33308;
  unsigned char D.33309;
  int D.33310;
  unsigned char D.33311;
  int D.33312;
  const unsigned char * D.33317;
  unsigned char D.33318;
  int D.33319;
  const unsigned char * D.33320;
  unsigned char D.33321;
  int D.33322;
  const unsigned char * D.33327;
  unsigned char D.33328;
  int D.33329;
  const unsigned char * D.33330;
  unsigned char D.33331;
  int D.33332;
  const unsigned char * D.33337;
  unsigned char D.33338;
  int D.33339;
  const unsigned char * D.33340;
  unsigned char D.33341;
  int D.33342;
  const char * D.33344;
  unsigned int D.33349;
  int D.33354;
  struct MonoGenericClass * D.33363;
  int D.33366;
  int D.33369;
  unsigned char D.33375;
  struct MonoDebugOptions * D.33376;
  int D.33377;
  struct MonoGenericInst * D.33392;
  int pass_vtable.114;
  struct MonoDebugOptions * D.33407;
  int D.33408;
  long int D.33410;
  struct MonoInst * D.33411;
  guint16 iftmp.115;
  int D.33416;
  int D.33417;
  long int D.33420;
  struct MonoInst * D.33421;
  int D.33422;
  int D.33423;
  struct MonoInst * iftmp.116;
  int D.33428;
  void * iftmp.117;
  unsigned int D.33434;
  int D.33435;
  int pass_mrgctx.118;
  _Bool D.33442;
  long int D.33443;
  long int D.33444;
  struct MonoDebugOptions * D.33452;
  int D.33453;
  int D.33457;
  int D.33459;
  unsigned int D.33462;
  _Bool D.33469;
  long int D.33470;
  long int D.33471;
  _Bool D.33474;
  long int D.33475;
  long int D.33476;
  long int D.33485;
  struct MonoInst * D.33486;
  int D.33487;
  int D.33488;
  long int D.33492;
  struct MonoInst * D.33493;
  int D.33494;
  int D.33495;
  long int D.33501;
  struct MonoInst * D.33502;
  int D.33503;
  int D.33504;
  long int D.33508;
  struct MonoInst * D.33509;
  int D.33510;
  int D.33511;
  long unsigned int D.33528;
  short unsigned int D.33529;
  int D.33533;
  long unsigned int D.33534;
  _Bool D.33535;
  long int D.33536;
  long int D.33537;
  int D.33548;
  const char * D.33553;
  gchar * D.33554;
  int mono_use_imt.119;
  _Bool D.33564;
  long int D.33565;
  long int D.33566;
  long unsigned int D.33571;
  _Bool D.33572;
  long int D.33573;
  long int D.33574;
  struct MonoType * D.33578;
  long int D.33579;
  struct MonoInst * D.33580;
  int D.33581;
  int D.33582;
  long int D.33583;
  long unsigned int D.33584;
  long unsigned int D.33585;
  struct MonoInst * * D.33586;
  struct MonoInst * D.33587;
  struct MonoType * D.33588;
  unsigned int D.33589;
  short unsigned int D.33590;
  struct MonoClass * D.33591;
  int D.33592;
  short unsigned int D.33593;
  struct MonoClass * D.33596;
  void * D.33600;
  struct MonoInst * D.33601;
  long int D.33602;
  struct MonoInst * D.33603;
  int D.33604;
  int D.33605;
  unsigned int D.33606;
  short unsigned int D.33607;
  unsigned char D.33608;
  <unnamed type> D.33609;
  unsigned int D.33610;
  int D.33611;
  short unsigned int D.33612;
  struct MonoClass * D.33615;
  struct MonoInst * D.33619;
  void * D.33620;
  struct MonoInst * D.33621;
  long int D.33622;
  struct MonoInst * D.33623;
  int D.33624;
  int D.33625;
  long int D.33626;
  long unsigned int D.33627;
  long unsigned int D.33628;
  struct MonoInst * * D.33629;
  struct MonoInst * D.33630;
  unsigned char D.33631;
  unsigned char D.33632;
  struct MonoClass * D.33633;
  unsigned int D.33634;
  int D.33635;
  struct MonoType * D.33638;
  int D.33639;
  struct MonoInst * iftmp.120;
  int D.33645;
  int D.33646;
  unsigned int D.33647;
  sizetype D.33650;
  sizetype D.33651;
  sizetype D.33652;
  struct MonoInst * * D.33653;
  struct MonoInst * iftmp.121;
  int D.33656;
  unsigned int D.33657;
  sizetype D.33660;
  sizetype D.33661;
  struct MonoInst * * D.33662;
  _Bool D.33664;
  long int D.33665;
  long int D.33666;
  _Bool D.33669;
  long int D.33670;
  long int D.33671;
  unsigned char D.33674;
  unsigned char D.33675;
  unsigned char D.33676;
  unsigned char D.33677;
  void * D.33681;
  long int D.33682;
  struct MonoInst * D.33683;
  int D.33684;
  int D.33685;
  unsigned int D.33686;
  short unsigned int D.33687;
  unsigned char D.33688;
  <unnamed type> D.33689;
  unsigned int D.33690;
  int D.33691;
  short unsigned int D.33692;
  struct MonoClass * D.33695;
  struct MonoClass * D.33701;
  int D.28006;
  int iftmp.122;
  int D.28005;
  const char[6] * D.33707;
  unsigned char D.33708;
  int D.33709;
  unsigned char D.33710;
  int D.33711;
  const unsigned char * D.33716;
  unsigned char D.33717;
  int D.33718;
  const unsigned char * D.33719;
  unsigned char D.33720;
  int D.33721;
  const unsigned char * D.33726;
  unsigned char D.33727;
  int D.33728;
  const unsigned char * D.33729;
  unsigned char D.33730;
  int D.33731;
  const unsigned char * D.33736;
  unsigned char D.33737;
  int D.33738;
  const unsigned char * D.33739;
  unsigned char D.33740;
  int D.33741;
  struct MonoMethodSignature * D.33745;
  short unsigned int D.33746;
  long int D.33749;
  long unsigned int D.33750;
  long unsigned int D.33751;
  struct MonoBasicBlock * * D.33752;
  const unsigned char * D.33758;
  struct MonoDebugOptions * D.33763;
  int D.33764;
  unsigned int D.33766;
  unsigned int D.33767;
  int D.33768;
  unsigned char * D.33769;
  long int D.33772;
  long int D.33773;
  long unsigned int D.33774;
  long unsigned int D.33775;
  struct MonoBasicBlock * * D.33776;
  long unsigned int D.33777;
  long unsigned int D.33778;
  unsigned int D.33781;
  unsigned int D.33782;
  int D.33791;
  unsigned int D.33798;
  int D.33807;
  struct GList * D.33810;
  int D.33816;
  unsigned int D.33825;
  int D.33826;
  unsigned int D.33829;
  struct MonoMethodSignature * D.33846;
  struct MonoType * D.33847;
  int D.33848;
  long unsigned int D.33853;
  long unsigned int D.33854;
  struct MonoType * * D.33855;
  struct MonoType * D.33856;
  unsigned int D.33857;
  short unsigned int D.33858;
  struct MonoInst * * D.33859;
  struct MonoInst * D.33860;
  struct MonoClass * D.33861;
  struct MonoInst * * D.33862;
  struct MonoInst * D.33863;
  int D.33864;
  int D.33865;
  struct MonoClass * D.33868;
  struct MonoBasicBlock * * D.33875;
  const guint8 * D.33876;
  int D.33877;
  int num_calls.123;
  int D.33881;
  int D.33885;
  long unsigned int D.33893;
  const char * D.33897;
  gchar * D.33898;
  _Bool D.33903;
  long int D.33904;
  long int D.33905;
  unsigned char D.33912;
  const char * D.33917;
  gchar * D.33918;
  int D.28027;
  int iftmp.124;
  int D.28026;
  unsigned char D.33926;
  int D.33927;
  const unsigned char * D.33932;
  unsigned char D.33933;
  int D.33934;
  const unsigned char * D.33939;
  unsigned char D.33940;
  int D.33941;
  const unsigned char * D.33946;
  unsigned char D.33947;
  int D.33948;
  int D.33960;
  const char * D.33967;
  gchar * D.33968;
  int D.33979;
  int D.33982;
  int D.33984;
  int iftmp.125;
  _Bool D.33999;
  long int D.34000;
  long int D.34001;
  _Bool D.34004;
  long int D.34005;
  long int D.34006;
  long int D.34015;
  struct MonoInst * D.34016;
  int D.34017;
  int D.34018;
  long int D.34022;
  struct MonoInst * D.34023;
  int D.34024;
  int D.34025;
  long int D.34031;
  struct MonoInst * D.34032;
  int D.34033;
  int D.34034;
  long int D.34038;
  struct MonoInst * D.34039;
  int D.34040;
  int D.34041;
  _Bool D.34049;
  long int D.34050;
  long int D.34051;
  short unsigned int D.34070;
  long int D.34077;
  struct MonoInst * D.34078;
  long int D.34079;
  unsigned int info_type.126;
  unsigned int D.34081;
  <unnamed type> info_type.127;
  int D.34085;
  int D.34086;
  int D.28044;
  int iftmp.128;
  int D.28043;
  const char[4] * D.34092;
  unsigned char D.34093;
  int D.34094;
  unsigned char D.34095;
  int D.34096;
  const unsigned char * D.34101;
  unsigned char D.34102;
  int D.34103;
  const unsigned char * D.34104;
  unsigned char D.34105;
  int D.34106;
  const unsigned char * D.34111;
  unsigned char D.34112;
  int D.34113;
  const unsigned char * D.34114;
  unsigned char D.34115;
  int D.34116;
  const unsigned char * D.34121;
  unsigned char D.34122;
  int D.34123;
  const unsigned char * D.34124;
  unsigned char D.34125;
  int D.34126;
  struct MonoInst * * D.34130;
  unsigned char D.34131;
  int D.34134;
  struct MonoType * D.34135;
  unsigned int D.34136;
  short unsigned int D.34137;
  int D.34138;
  int D.34139;
  struct MonoClass * D.34140;
  long unsigned int D.34146;
  short unsigned int D.34151;
  long int D.34153;
  int D.28055;
  int iftmp.129;
  int D.28054;
  const char[4] * D.34158;
  unsigned char D.34159;
  int D.34160;
  unsigned char D.34161;
  int D.34162;
  const unsigned char * D.34167;
  unsigned char D.34168;
  int D.34169;
  const unsigned char * D.34170;
  unsigned char D.34171;
  int D.34172;
  const unsigned char * D.34177;
  unsigned char D.34178;
  int D.34179;
  const unsigned char * D.34180;
  unsigned char D.34181;
  int D.34182;
  const unsigned char * D.34187;
  unsigned char D.34188;
  int D.34189;
  const unsigned char * D.34190;
  unsigned char D.34191;
  int D.34192;
  unsigned int D.34196;
  short unsigned int D.34197;
  unsigned int D.34198;
  int D.34199;
  int D.28064;
  int iftmp.130;
  int D.28063;
  const char[8] * D.34207;
  unsigned char D.34208;
  int D.34209;
  unsigned char D.34210;
  int D.34211;
  const unsigned char * D.34216;
  unsigned char D.34217;
  int D.34218;
  const unsigned char * D.34219;
  unsigned char D.34220;
  int D.34221;
  const unsigned char * D.34226;
  unsigned char D.34227;
  int D.34228;
  const unsigned char * D.34229;
  unsigned char D.34230;
  int D.34231;
  const unsigned char * D.34236;
  unsigned char D.34237;
  int D.34238;
  const unsigned char * D.34239;
  unsigned char D.34240;
  int D.34241;
  struct MonoClass * D.34245;
  long unsigned int D.34246;
  long unsigned int D.34247;
  struct MonoDebugOptions * D.34255;
  int D.34256;
  struct MonoInst * iftmp.131;
  unsigned int D.34266;
  int call_opcode.132;
  int D.34274;
  int D.34288;
  int D.34289;
  struct MonoMethodSignature * D.34290;
  struct MonoType * * D.34291;
  struct MonoType * D.34292;
  unsigned int D.34293;
  short unsigned int D.34294;
  struct MonoInst * * D.34295;
  struct MonoInst * D.34296;
  struct MonoClass * D.34297;
  struct MonoInst * * D.34298;
  struct MonoInst * D.34299;
  int D.34300;
  int D.34301;
  struct MonoClass * D.34304;
  struct MonoDebugOptions * D.34320;
  int D.34321;
  unsigned int D.34323;
  unsigned int D.34324;
  int D.34325;
  short int D.34331;
  struct MonoMethod * D.34338;
  struct MonoInst * iftmp.133;
  struct MonoDebugOptions * D.34360;
  int D.34361;
  unsigned int D.34363;
  unsigned int D.34364;
  int D.34365;
  int D.34373;
  _Bool D.34376;
  long int D.34377;
  long int D.34378;
  struct MonoInst * * sp.134;
  struct MonoInst * D.34384;
  struct MonoInst * * sp.135;
  long int D.34389;
  struct MonoInst * D.34390;
  int D.34391;
  int D.34392;
  int D.34393;
  _Bool D.34400;
  long int D.34401;
  long int D.34402;
  short int D.34411;
  struct MonoMethodSignature * D.34414;
  struct MonoDebugOptions * D.34421;
  int D.34422;
  int D.34427;
  struct MonoDebugOptions * D.34434;
  int D.34435;
  long int D.34437;
  struct MonoInst * D.34438;
  int D.34439;
  int D.34440;
  long int D.34441;
  long unsigned int D.34442;
  long unsigned int D.34443;
  struct MonoInst * * D.34444;
  struct MonoInst * D.34445;
  struct MonoType * D.34446;
  unsigned int D.34447;
  short unsigned int D.34448;
  struct MonoClass * D.34449;
  int D.34450;
  short unsigned int D.34451;
  struct MonoClass * D.34454;
  struct MonoInst * D.34459;
  struct MonoInst * D.34464;
  struct MonoMethodSignature * D.34467;
  struct MonoType * D.34468;
  _Bool D.34476;
  long int D.34477;
  long int D.34478;
  struct MonoDebugOptions * D.34487;
  int D.34488;
  int D.34493;
  struct MonoDebugOptions * D.34500;
  int D.34501;
  unsigned int D.34503;
  struct MonoInst * D.34506;
  long int D.34509;
  struct MonoInst * D.34510;
  int D.34511;
  int D.34512;
  unsigned int D.34513;
  short unsigned int D.34514;
  struct MonoClass * D.34515;
  int D.34516;
  short unsigned int D.34517;
  struct MonoClass * D.34520;
  long int D.34525;
  struct MonoInst * D.34526;
  int D.34527;
  int D.34528;
  int D.34529;
  unsigned char D.34530;
  <unnamed type> D.34531;
  unsigned int D.34532;
  int D.34533;
  int D.34537;
  struct MonoClass * D.34541;
  struct MonoDebugOptions * D.34549;
  int D.34550;
  struct MonoDebugOptions * D.34561;
  int D.34562;
  signed char D.34564;
  sizetype D.34565;
  sizetype D.34566;
  long int target.136;
  long int D.34568;
  long unsigned int D.34569;
  long unsigned int D.34570;
  struct MonoBasicBlock * * D.34571;
  struct MonoDebugOptions * D.34581;
  int D.34582;
  unsigned int D.34584;
  unsigned int D.34585;
  int D.34586;
  struct MonoDebugOptions * D.34597;
  int D.34598;
  struct MonoDebugOptions * D.34609;
  int D.34610;
  struct MonoDebugOptions * D.34618;
  int D.34619;
  short unsigned int D.34621;
  short unsigned int D.34622;
  sizetype D.34623;
  sizetype D.34624;
  long int D.34625;
  struct MonoInst * D.34626;
  int D.34627;
  int D.34628;
  unsigned char D.34629;
  struct MonoDebugOptions * D.34636;
  int D.34637;
  void * D.34639;
  struct MonoDebugOptions * D.34649;
  int D.34650;
  unsigned int D.34652;
  unsigned int D.34653;
  int D.34654;
  struct MonoBasicBlock * * D.34657;
  struct MonoBasicBlock * * D.34660;
  struct MonoDebugOptions * D.34671;
  int D.34672;
  unsigned int D.34674;
  unsigned int D.34675;
  int D.34676;
  struct MonoDebugOptions * D.34687;
  int D.34688;
  struct MonoDebugOptions * D.34702;
  int D.34703;
  int D.34705;
  sizetype D.34706;
  sizetype D.34707;
  struct MonoDebugOptions * D.34717;
  int D.34718;
  unsigned int D.34720;
  unsigned int D.34721;
  int D.34722;
  struct MonoDebugOptions * D.34733;
  int D.34734;
  unsigned char D.34739;
  _Bool D.34740;
  int iftmp.137;
  guint32 iftmp.138;
  sizetype D.34750;
  unsigned char * D.34751;
  struct MonoDebugOptions * D.34758;
  int D.34759;
  struct MonoDebugOptions * D.34767;
  int D.34768;
  struct MonoInst * * D.34772;
  struct MonoInst * D.34773;
  unsigned char D.34774;
  struct MonoDebugOptions * D.34780;
  int D.34781;
  sizetype iftmp.139;
  sizetype D.34787;
  struct MonoDebugOptions * D.34797;
  int D.34798;
  unsigned int D.34800;
  unsigned int D.34801;
  int D.34802;
  struct MonoDebugOptions * D.34814;
  int D.34815;
  unsigned int D.34817;
  unsigned int D.34818;
  int D.34819;
  struct MonoDebugOptions * D.34830;
  int D.34831;
  long int D.34833;
  struct MonoInst * D.34834;
  int D.34835;
  int D.34836;
  unsigned char D.34837;
  struct MonoDebugOptions * D.34844;
  int D.34845;
  guint16 iftmp.140;
  void * D.34857;
  struct MonoDebugOptions * D.34867;
  int D.34868;
  unsigned int D.34870;
  unsigned int D.34871;
  int D.34872;
  struct MonoDebugOptions * D.34884;
  int D.34885;
  unsigned int D.34887;
  unsigned int D.34888;
  int D.34889;
  struct MonoDebugOptions * D.34898;
  int D.34899;
  struct MonoDebugOptions * D.34907;
  int D.34908;
  long int D.34910;
  struct MonoInst * D.34911;
  int D.34912;
  int D.34913;
  unsigned char D.34914;
  struct MonoDebugOptions * D.34921;
  int D.34922;
  void * D.34924;
  struct MonoDebugOptions * D.34934;
  int D.34935;
  unsigned int D.34937;
  unsigned int D.34938;
  int D.34939;
  struct MonoDebugOptions * D.34954;
  int D.34955;
  unsigned int D.34957;
  unsigned int D.34958;
  int D.34959;
  struct MonoDebugOptions * D.34970;
  int D.34971;
  unsigned int D.34979;
  unsigned int D.34980;
  unsigned int D.34981;
  unsigned int D.34982;
  struct MonoDebugOptions * D.34989;
  int D.34990;
  struct MonoDebugOptions * D.34998;
  int D.34999;
  unsigned char D.35001;
  struct MonoDebugOptions * D.35010;
  int D.35011;
  long unsigned int D.35013;
  unsigned char * D.35014;
  struct MonoDebugOptions * D.35021;
  int D.35022;
  struct MonoDebugOptions * D.35033;
  int D.35034;
  unsigned int D.35036;
  unsigned int D.35037;
  int D.35038;
  unsigned char * D.35039;
  long int D.35042;
  long int D.35043;
  long unsigned int D.35044;
  long unsigned int D.35045;
  struct MonoBasicBlock * * D.35046;
  unsigned int D.35047;
  unsigned int D.35048;
  unsigned int D.35049;
  unsigned int D.35050;
  unsigned char * D.35051;
  long int D.35052;
  long int D.35053;
  long unsigned int D.35054;
  long unsigned int D.35055;
  struct MonoBasicBlock * * D.35056;
  const unsigned char * D.35062;
  struct MonoDebugOptions * D.35067;
  int D.35068;
  unsigned int D.35070;
  unsigned int D.35071;
  int D.35072;
  struct MonoBasicBlock * * D.35075;
  struct MonoBasicBlock * D.35076;
  unsigned int D.35077;
  unsigned int D.35078;
  struct MonoDebugOptions * D.35087;
  int D.35088;
  long int D.35090;
  struct MonoInst * D.35091;
  int D.35092;
  int D.35093;
  int D.35094;
  long int D.35098;
  struct MonoInst * D.35099;
  int D.35100;
  int D.35101;
  unsigned int D.35104;
  unsigned int D.35105;
  int D.35106;
  unsigned char * D.35110;
  long int D.35113;
  long int D.35114;
  long unsigned int D.35115;
  long unsigned int D.35116;
  struct MonoBasicBlock * * D.35117;
  short unsigned int D.35122;
  short unsigned int D.35123;
  short unsigned int D.35125;
  short unsigned int D.35127;
  struct MonoBasicBlock * * D.35128;
  struct MonoBasicBlock * * D.35129;
  struct MonoBasicBlock * D.35130;
  void * D.35140;
  struct MonoBasicBlock * * D.35141;
  struct MonoBasicBlock * * D.35142;
  long unsigned int D.35146;
  unsigned int D.35149;
  unsigned int D.35150;
  int D.35151;
  struct MonoClass * D.35173;
  long int D.35180;
  struct MonoInst * D.35181;
  int D.35182;
  int D.35183;
  long int D.35188;
  struct MonoInst * D.35189;
  int D.35190;
  int D.35191;
  long int D.35195;
  struct MonoInst * D.35196;
  int D.35197;
  int D.35198;
  long int D.35204;
  struct MonoInst * D.35205;
  guint16 iftmp.141;
  int D.35210;
  int D.35211;
  long int D.35214;
  struct MonoInst * D.35215;
  int D.35216;
  int D.35217;
  int D.35218;
  unsigned int D.35220;
  int D.35221;
  long int D.35229;
  struct MonoInst * D.35230;
  int D.35231;
  int D.35232;
  long int D.35236;
  struct MonoInst * D.35237;
  int D.35238;
  int D.35239;
  long int D.35243;
  struct MonoInst * D.35244;
  int D.35245;
  int D.35246;
  struct MonoDebugOptions * D.35256;
  int D.35257;
  unsigned int D.35259;
  unsigned int D.35260;
  unsigned int D.35261;
  unsigned int D.35262;
  int D.35263;
  short unsigned int D.35264;
  int D.35265;
  char D.35266;
  unsigned char D.35267;
  unsigned char D.35268;
  struct MonoInst * * sp.142;
  int D.35273;
  int D.35274;
  struct MonoDebugOptions * D.35283;
  int D.35284;
  int D.35286;
  short unsigned int D.35287;
  short unsigned int D.35301;
  void * D.35303;
  struct MonoDebugOptions * D.35310;
  int D.35311;
  struct MonoDebugOptions * D.35319;
  int D.35320;
  unsigned int D.35322;
  int D.35323;
  long int D.35326;
  int D.35327;
  int D.35330;
  short unsigned int D.35333;
  void * D.35334;
  struct MonoInst * * sp.143;
  struct MonoInst * D.35339;
  struct MonoDebugOptions * D.35346;
  int D.35347;
  struct MonoDebugOptions * D.35355;
  int D.35356;
  unsigned char D.35360;
  unsigned int D.35363;
  long int D.35364;
  struct MonoInst * D.35365;
  int D.35366;
  int D.35367;
  int D.35371;
  unsigned int D.35372;
  int D.35373;
  short unsigned int D.35374;
  long int iftmp.144;
  int D.35381;
  short unsigned int D.35386;
  long int D.35389;
  struct MonoInst * D.35391;
  struct MonoInst * * sp.145;
  struct MonoInst * D.35398;
  struct MonoDebugOptions * D.35405;
  int D.35406;
  short unsigned int D.35412;
  long int D.35414;
  unsigned int data.146;
  long int D.35418;
  long int D.35420;
  unsigned int D.35421;
  int D.35422;
  struct MonoDebugOptions * D.35429;
  int D.35430;
  unsigned int D.35432;
  int D.35433;
  struct MonoInst * * sp.147;
  struct MonoInst * D.35438;
  struct MonoDebugOptions * D.35445;
  int D.35446;
  struct MonoDebugOptions * D.35456;
  int D.35457;
  unsigned int D.35459;
  int D.35460;
  struct MonoInst * * sp.148;
  struct MonoInst * D.35465;
  struct MonoDebugOptions * D.35472;
  int D.35473;
  unsigned int D.35475;
  int D.35476;
  struct MonoInst * * sp.149;
  struct MonoInst * D.35481;
  struct MonoDebugOptions * D.35489;
  int D.35490;
  unsigned int D.35492;
  int D.35493;
  struct MonoInst * * sp.150;
  struct MonoInst * D.35498;
  struct MonoDebugOptions * D.35505;
  int D.35506;
  struct MonoDebugOptions * D.35516;
  int D.35517;
  unsigned int D.35519;
  int D.35520;
  struct MonoInst * * sp.151;
  struct MonoInst * D.35525;
  struct MonoDebugOptions * D.35532;
  int D.35533;
  unsigned int D.35535;
  int D.35536;
  struct MonoInst * * sp.152;
  struct MonoInst * D.35541;
  struct MonoDebugOptions * D.35549;
  int D.35550;
  unsigned int D.35552;
  int D.35553;
  struct MonoInst * * sp.153;
  struct MonoInst * D.35558;
  struct MonoDebugOptions * D.35565;
  int D.35566;
  struct MonoDebugOptions * D.35574;
  int D.35575;
  unsigned int D.35577;
  int D.35578;
  struct MonoInst * * sp.154;
  struct MonoInst * D.35583;
  struct MonoDebugOptions * D.35591;
  int D.35592;
  struct MonoDebugOptions * D.35600;
  int D.35601;
  unsigned int D.35607;
  long int D.35608;
  struct MonoInst * D.35609;
  int D.35610;
  int D.35611;
  int D.35615;
  unsigned int D.35616;
  int D.35617;
  struct MonoInst * * sp.155;
  struct MonoInst * D.35622;
  const char * D.35625;
  gchar * D.35626;
  struct MonoDebugOptions * D.35635;
  int D.35636;
  struct MonoDebugOptions * D.35644;
  int D.35645;
  struct MonoClass * klass.156;
  struct MonoClass * klass.157;
  unsigned char D.35652;
  struct MonoDebugOptions * D.35653;
  int D.35654;
  int D.35656;
  unsigned int D.35659;
  long int D.35660;
  struct MonoInst * D.35661;
  int D.35662;
  int D.35663;
  unsigned char D.35664;
  unsigned char D.35665;
  long int D.35669;
  struct MonoInst * D.35670;
  int D.35671;
  int D.35672;
  unsigned char D.35673;
  unsigned char D.35674;
  struct MonoDebugOptions * D.35689;
  int D.35690;
  struct MonoDebugOptions * D.35698;
  int D.35699;
  struct MonoClass * klass.158;
  struct MonoDebugOptions * D.35705;
  int D.35706;
  int D.35708;
  unsigned char * D.35709;
  unsigned char D.35710;
  int D.35713;
  unsigned int loc_index.159;
  struct MonoDebugOptions * D.35723;
  int D.35724;
  struct MonoType * D.35726;
  unsigned int D.35727;
  short unsigned int D.35728;
  unsigned int D.35729;
  int D.35730;
  long unsigned int D.35734;
  long unsigned int D.35735;
  struct MonoInst * * D.35736;
  struct MonoInst * D.35737;
  int D.35738;
  sizetype D.35739;
  int D.35742;
  const guint32 * D.35745;
  unsigned int D.35746;
  int D.35749;
  struct MonoDebugOptions * D.35758;
  int D.35759;
  unsigned int D.35761;
  short unsigned int D.35762;
  unsigned int D.35763;
  int D.35764;
  struct MonoInst * * sp.160;
  struct MonoDebugOptions * D.35775;
  int D.35776;
  struct MonoDebugOptions * D.35784;
  int D.35785;
  unsigned int n.161;
  void * D.35790;
  unsigned int D.35791;
  int D.35792;
  void * D.35799;
  struct MonoInst * D.35800;
  long int D.35801;
  struct MonoInst * D.35802;
  int D.35803;
  int D.35804;
  void * D.35805;
  unsigned int D.35806;
  int D.35807;
  struct MonoInst * D.35811;
  struct GList * D.35817;
  void * D.35818;
  struct GList * D.35819;
  void * D.35824;
  struct MonoInst * D.35825;
  long int D.35826;
  struct MonoInst * D.35827;
  int D.35828;
  int D.35829;
  long int D.35830;
  long unsigned int D.35831;
  long unsigned int D.35832;
  struct MonoInst * * D.35833;
  struct MonoInst * D.35834;
  struct MonoType * D.35835;
  unsigned int D.35836;
  short unsigned int D.35837;
  struct MonoClass * D.35838;
  int D.35839;
  unsigned char D.35840;
  <unnamed type> D.35841;
  unsigned int D.35842;
  int D.35843;
  short unsigned int D.35844;
  struct MonoClass * D.35847;
  void * D.35848;
  unsigned int D.35849;
  int D.35850;
  void * D.35854;
  struct MonoInst * D.35855;
  long int D.35856;
  struct MonoInst * D.35857;
  guint16 iftmp.162;
  int D.35862;
  int D.35863;
  long int D.35866;
  struct MonoInst * D.35867;
  int D.35868;
  int D.35869;
  int D.35870;
  unsigned int D.35872;
  int D.35873;
  void * D.35877;
  struct MonoInst * D.35878;
  long int D.35879;
  struct MonoInst * D.35880;
  int D.35881;
  int D.35882;
  unsigned int n.163;
  long int D.35884;
  long int D.35885;
  unsigned int D.35886;
  int D.35887;
  struct MonoInst * D.35891;
  unsigned int n.164;
  unsigned int D.35893;
  long unsigned int D.35895;
  long unsigned int D.35896;
  void * D.35901;
  struct MonoInst * D.35902;
  long int D.35903;
  struct MonoInst * D.35904;
  int D.35905;
  int D.35906;
  unsigned int D.35907;
  int D.35908;
  struct MonoInst * D.35912;
  void * D.35914;
  guint16 iftmp.165;
  long int D.35921;
  struct MonoInst * D.35922;
  int D.35923;
  int D.35924;
  int D.35925;
  unsigned int D.35927;
  int D.35928;
  void * D.35932;
  struct MonoInst * D.35933;
  long int D.35934;
  struct MonoInst * D.35935;
  int D.35936;
  int D.35937;
  unsigned int D.35938;
  int D.35939;
  struct MonoInst * D.35943;
  long int D.35947;
  struct MonoInst * D.35948;
  int D.35949;
  int D.35950;
  struct MonoJumpInfoToken * D.35951;
  int D.35952;
  struct MonoClass * D.35953;
  unsigned int D.35954;
  int D.35955;
  unsigned int D.35960;
  int D.35961;
  struct MonoString * D.35962;
  void * D.35963;
  struct MonoDebugOptions * D.35975;
  int D.35976;
  struct MonoLoaderError * D.35981;
  struct MonoDebugOptions * D.35982;
  int D.35983;
  struct MonoDebugOptions * D.35987;
  int D.35988;
  int D.35990;
  struct MonoDebugOptions * D.35993;
  int D.35994;
  <unnamed type> D.35998;
  int D.36001;
  <unnamed type> D.36012;
  int D.36023;
  int D.36026;
  struct MonoDebugOptions * D.36032;
  int D.36033;
  int D.36037;
  int D.36040;
  struct MonoGenericContext * D.36046;
  struct MonoGenericInst * D.36047;
  struct MonoDebugOptions * D.36052;
  int D.36053;
  struct MonoDebugOptions * D.36061;
  int D.36062;
  long int D.36064;
  struct MonoInst * D.36065;
  guint16 iftmp.166;
  int D.36070;
  int D.36071;
  long int D.36074;
  struct MonoInst * D.36075;
  int D.36076;
  int D.36077;
  struct MonoInst * iftmp.167;
  int D.36082;
  void * iftmp.168;
  unsigned int D.36088;
  int D.36089;
  short unsigned int D.36093;
  struct MonoDebugOptions * D.36100;
  int D.36101;
  int D.36110;
  struct MonoType * D.36116;
  long unsigned int D.36117;
  long unsigned int D.36118;
  struct MonoType * D.36120;
  long unsigned int D.36121;
  long unsigned int D.36122;
  _Bool D.36123;
  long int D.36124;
  long int D.36125;
  void * D.36128;
  struct MonoInst * D.36129;
  long int D.36130;
  struct MonoInst * D.36131;
  int D.36132;
  int D.36133;
  unsigned int D.36134;
  long int D.36135;
  unsigned int D.36136;
  int D.36137;
  struct MonoInst * * sp.169;
  struct MonoInst * D.36142;
  struct MonoInst * * sp.170;
  struct MonoInst * D.36144;
  struct MonoInst * D.36145;
  struct MonoInst * * sp.171;
  struct MonoInst * D.36147;
  int n.172;
  int D.36149;
  struct MonoDebugOptions * D.36156;
  int D.36157;
  int D.36159;
  struct MonoInst * D.36164;
  int D.36177;
  _Bool D.36181;
  long int D.36182;
  long int D.36183;
  void * D.36188;
  unsigned int D.36189;
  int D.36190;
  struct MonoType * D.36197;
  struct MonoInst * D.36198;
  struct MonoInst * D.36199;
  int D.36200;
  void * D.36201;
  long int D.36202;
  long unsigned int D.36203;
  long unsigned int D.36204;
  struct MonoInst * * D.36205;
  struct MonoInst * D.36206;
  unsigned char D.36207;
  unsigned char D.36208;
  struct MonoClass * D.36209;
  unsigned int D.36210;
  int D.36211;
  struct MonoType * D.36214;
  int D.36215;
  struct MonoInst * iftmp.173;
  int D.36221;
  int D.36222;
  unsigned int D.36223;
  sizetype D.36226;
  sizetype D.36227;
  sizetype D.36228;
  struct MonoInst * * D.36229;
  struct MonoInst * iftmp.174;
  int D.36232;
  unsigned int D.36233;
  sizetype D.36236;
  sizetype D.36237;
  struct MonoInst * * D.36238;
  _Bool D.36240;
  long int D.36241;
  long int D.36242;
  _Bool D.36245;
  long int D.36246;
  long int D.36247;
  unsigned char D.36250;
  unsigned char D.36251;
  unsigned char D.36252;
  unsigned char D.36253;
  struct MonoDebugOptions * D.36266;
  int D.36267;
  int D.36269;
  struct GSList * D.36272;
  struct MonoMethodSignature * helper_sig_class_init_trampoline.175;
  const char * D.36278;
  const char * D.36279;
  long int D.36283;
  struct MonoInst * D.36284;
  int D.36285;
  int D.36286;
  int D.36287;
  struct MonoType * D.36298;
  int D.36299;
  int D.36310;
  struct MonoClass * D.36312;
  int D.36313;
  struct GList * D.36315;
  int D.36319;
  int D.36329;
  const char * D.36334;
  gchar * D.36335;
  int D.36341;
  int D.36347;
  int D.36349;
  unsigned int D.36358;
  short unsigned int D.36359;
  unsigned int D.36360;
  int D.36361;
  struct MonoClass * D.36364;
  struct MonoClass * D.36368;
  struct MonoType * D.36369;
  struct MonoInst * * sp.176;
  struct MonoInst * * sp.177;
  struct MonoDebugOptions * D.36379;
  int D.36380;
  struct MonoDebugOptions * D.36388;
  int D.36389;
  struct MonoClass * klass.178;
  struct MonoDebugOptions * D.36395;
  int D.36396;
  struct MonoDebugOptions * D.36404;
  int D.36405;
  int D.36410;
  void * D.36412;
  struct MonoInst * D.36413;
  long int D.36414;
  struct MonoInst * D.36415;
  guint16 iftmp.179;
  int D.36420;
  int D.36421;
  long int D.36424;
  struct MonoInst * D.36425;
  int D.36426;
  int D.36427;
  int D.36428;
  unsigned int D.36430;
  int D.36431;
  void * D.36437;
  struct MonoInst * D.36438;
  long int D.36439;
  struct MonoInst * D.36440;
  guint16 iftmp.180;
  int D.36445;
  int D.36446;
  long int D.36449;
  struct MonoInst * D.36450;
  int D.36451;
  int D.36452;
  int D.36453;
  unsigned int D.36455;
  int D.36456;
  void * D.36461;
  void * D.36462;
  unsigned int D.36463;
  int D.36464;
  struct MonoInst * * sp.181;
  struct MonoInst * D.36469;
  long unsigned int D.36474;
  long unsigned int D.36475;
  unsigned int D.36477;
  unsigned int D.36478;
  struct MonoMethodSignature * D.36479;
  _Bool D.36481;
  long int D.36482;
  long int D.36483;
  struct MonoInst * * sp.182;
  struct MonoInst * D.36487;
  struct MonoInst * * sp.183;
  struct MonoDebugOptions * D.36496;
  int D.36497;
  struct MonoDebugOptions * D.36505;
  int D.36506;
  struct MonoClass * klass.184;
  struct MonoDebugOptions * D.36512;
  int D.36513;
  struct MonoDebugOptions * D.36521;
  int D.36522;
  int D.36527;
  void * D.36529;
  struct MonoInst * D.36530;
  long int D.36531;
  struct MonoInst * D.36532;
  guint16 iftmp.185;
  int D.36537;
  int D.36538;
  long int D.36541;
  struct MonoInst * D.36542;
  int D.36543;
  int D.36544;
  int D.36545;
  unsigned int D.36547;
  int D.36548;
  void * D.36554;
  struct MonoInst * D.36555;
  long int D.36556;
  struct MonoInst * D.36557;
  guint16 iftmp.186;
  int D.36562;
  int D.36563;
  long int D.36566;
  struct MonoInst * D.36567;
  int D.36568;
  int D.36569;
  int D.36570;
  unsigned int D.36572;
  int D.36573;
  void * D.36578;
  void * D.36579;
  unsigned int D.36580;
  int D.36581;
  struct MonoInst * * sp.187;
  struct MonoInst * D.36586;
  struct MonoMethodSignature * D.36592;
  _Bool D.36594;
  long int D.36595;
  long int D.36596;
  struct MonoInst * * sp.188;
  struct MonoInst * D.36600;
  struct MonoInst * * sp.189;
  struct MonoDebugOptions * D.36609;
  int D.36610;
  struct MonoDebugOptions * D.36618;
  int D.36619;
  struct MonoClass * klass.190;
  struct MonoDebugOptions * D.36625;
  int D.36626;
  int D.36628;
  struct MonoInst * D.36631;
  int D.36632;
  int D.36638;
  void * D.36640;
  struct MonoInst * D.36641;
  long int D.36642;
  struct MonoInst * D.36643;
  guint16 iftmp.191;
  int D.36648;
  int D.36649;
  long int D.36652;
  struct MonoInst * D.36653;
  int D.36654;
  int D.36655;
  int D.36656;
  unsigned int D.36658;
  int D.36659;
  void * D.36665;
  struct MonoInst * D.36666;
  long int D.36667;
  struct MonoInst * D.36668;
  guint16 iftmp.192;
  int D.36673;
  int D.36674;
  long int D.36677;
  struct MonoInst * D.36678;
  int D.36679;
  int D.36680;
  int D.36681;
  unsigned int D.36683;
  int D.36684;
  void * D.36689;
  void * D.36690;
  unsigned int D.36691;
  int D.36692;
  struct MonoInst * * sp.193;
  struct MonoInst * D.36697;
  struct MonoMethodSignature * D.36703;
  _Bool D.36705;
  long int D.36706;
  long int D.36707;
  struct MonoInst * * sp.194;
  struct MonoInst * D.36711;
  struct MonoInst * * sp.195;
  int D.36714;
  struct MonoInst * * sp.196;
  unsigned int D.36718;
  short unsigned int D.36719;
  unsigned int D.36720;
  int D.36721;
  struct MonoInst * * sp.197;
  struct MonoDebugOptions * D.36732;
  int D.36733;
  struct MonoDebugOptions * D.36741;
  int D.36742;
  struct MonoClass * klass.198;
  struct MonoDebugOptions * D.36748;
  int D.36749;
  int D.36751;
  struct MonoInst * * sp.199;
  struct MonoClass * D.36755;
  struct MonoDebugOptions * D.36762;
  int D.36763;
  int D.36765;
  struct MonoDebugOptions * D.36772;
  int D.36773;
  int D.36777;
  int D.36782;
  int iftmp.200;
  char * D.36795;
  struct MonoDebugOptions * D.36802;
  int D.36803;
  struct MonoDebugOptions * D.36811;
  int D.36812;
  struct MonoDebugOptions * D.36823;
  int D.36824;
  unsigned int D.36826;
  unsigned int D.36827;
  int D.36828;
  unsigned char * D.36829;
  long int D.36832;
  long int D.36833;
  long unsigned int D.36834;
  long unsigned int D.36835;
  struct MonoBasicBlock * * D.36836;
  struct MonoDebugOptions * D.36846;
  int D.36847;
  unsigned int D.36849;
  unsigned int D.36850;
  int D.36851;
  unsigned char * D.36852;
  long int D.36855;
  long int D.36856;
  long unsigned int D.36857;
  long unsigned int D.36858;
  struct MonoBasicBlock * * D.36859;
  struct MonoDebugOptions * D.36868;
  int D.36869;
  unsigned int D.36873;
  long int D.36874;
  struct MonoInst * D.36875;
  int D.36876;
  int D.36877;
  long int D.36881;
  struct MonoInst * D.36882;
  int D.36883;
  int D.36884;
  _Bool D.36885;
  int D.36886;
  long int D.36887;
  long int D.36891;
  struct MonoInst * D.36892;
  int D.36893;
  int D.36894;
  void * D.36895;
  struct MonoBasicBlock * * D.36896;
  struct MonoBasicBlock * * D.36897;
  struct MonoBasicBlock * iftmp.201;
  struct MonoInst * * sp.202;
  struct MonoInst * D.36910;
  struct MonoDebugOptions * D.36918;
  int D.36919;
  struct MonoDebugOptions * D.36927;
  int D.36928;
  struct MonoClass * klass.203;
  struct MonoDebugOptions * D.36934;
  int D.36935;
  int D.36937;
  void * iftmp.204;
  int D.36941;
  unsigned int D.36942;
  long unsigned int D.36945;
  long unsigned int D.36946;
  struct MonoInst * * D.36947;
  struct MonoInst * iftmp.205;
  struct MonoInst * iftmp.206;
  unsigned char D.36957;
  unsigned char D.36958;
  struct MonoInst * iftmp.207;
  struct MonoClass * D.36963;
  unsigned int D.36964;
  int D.36965;
  struct MonoInst * iftmp.208;
  struct MonoType * D.36972;
  int D.36973;
  struct MonoInst * iftmp.209;
  struct MonoInst * iftmp.210;
  int D.36983;
  int D.36984;
  unsigned int D.36985;
  struct MonoInst * iftmp.211;
  int D.36992;
  sizetype D.36993;
  sizetype D.36994;
  sizetype D.36995;
  struct MonoInst * * D.36996;
  struct MonoInst * iftmp.212;
  struct MonoInst * iftmp.213;
  int D.37003;
  int D.37004;
  unsigned int D.37005;
  struct MonoInst * iftmp.214;
  int D.37012;
  sizetype D.37013;
  sizetype D.37014;
  sizetype D.37015;
  struct MonoInst * * D.37016;
  _Bool D.37018;
  long int D.37019;
  long int D.37020;
  _Bool D.37023;
  long int D.37024;
  long int D.37025;
  unsigned char D.37028;
  unsigned char D.37029;
  unsigned char D.37030;
  unsigned char D.37031;
  struct MonoInst * * sp.215;
  struct MonoInst * * sp.216;
  unsigned int op.217;
  unsigned int D.37039;
  _Bool D.37040;
  struct MonoDebugOptions * D.37051;
  int D.37052;
  struct MonoDebugOptions * D.37061;
  int D.37062;
  unsigned char D.37066;
  struct MonoDebugOptions * D.37072;
  int D.37073;
  struct MonoDebugOptions * D.37083;
  int D.37084;
  struct MonoDebugOptions * D.37095;
  int D.37096;
  struct MonoDebugOptions * D.37104;
  int D.37105;
  struct MonoClass * klass.218;
  struct MonoDebugOptions * D.37113;
  int D.37114;
  int D.37120;
  gchar * D.37123;
  int D.37128;
  struct MonoDebugOptions * D.37135;
  int D.37136;
  <unnamed type> D.37140;
  struct MonoType * D.37145;
  short unsigned int D.37146;
  int D.37147;
  int D.37148;
  guint iftmp.219;
  long unsigned int D.37152;
  int D.37155;
  unsigned int D.37156;
  int D.37160;
  struct MonoDebugOptions * D.37167;
  int D.37168;
  struct MonoMethodSignature * D.37175;
  long unsigned int D.37176;
  long unsigned int D.37177;
  int D.37180;
  long unsigned int D.37181;
  struct MonoClass * D.37183;
  const char * D.37186;
  gchar * D.37187;
  void * D.37190;
  struct MonoInst * D.37191;
  long int D.37192;
  struct MonoInst * D.37193;
  guint16 iftmp.220;
  int D.37198;
  int D.37199;
  long int D.37202;
  struct MonoInst * D.37203;
  int D.37204;
  int D.37205;
  int D.37206;
  unsigned int D.37208;
  int D.37209;
  void * D.37213;
  struct MonoInst * D.37214;
  long int D.37215;
  struct MonoInst * D.37216;
  guint16 iftmp.221;
  int D.37221;
  int D.37222;
  long int D.37225;
  struct MonoInst * D.37226;
  int D.37227;
  int D.37228;
  int D.37229;
  unsigned int D.37231;
  int D.37232;
  void * D.37236;
  struct MonoInst * D.37237;
  long int D.37238;
  struct MonoInst * D.37239;
  int D.37240;
  int D.37241;
  mgreg_t iftmp.222;
  long unsigned int D.37245;
  long unsigned int D.37246;
  unsigned int D.37248;
  int D.37249;
  struct MonoMethodSignature * D.37257;
  _Bool D.37259;
  long int D.37260;
  long int D.37261;
  long int D.37266;
  struct MonoInst * D.37267;
  int D.37268;
  int D.37269;
  long int D.37273;
  struct MonoInst * D.37274;
  int D.37275;
  int D.37276;
  int D.37281;
  unsigned int D.37284;
  int D.37285;
  long int D.37289;
  struct MonoInst * D.37290;
  unsigned int D.37291;
  short unsigned int D.37292;
  int D.37293;
  int D.37294;
  struct MonoClass * D.37295;
  unsigned int D.37300;
  short unsigned int D.37301;
  long int D.37302;
  struct MonoClass * D.37303;
  unsigned char D.37309;
  unsigned char D.37310;
  unsigned int D.37315;
  unsigned int D.37319;
  long int D.37320;
  struct MonoInst * D.37321;
  int D.37322;
  int D.37323;
  unsigned char D.37327;
  struct MonoMethodSignature * D.37334;
  long unsigned int D.37335;
  long unsigned int D.37336;
  struct MonoMethod * iftmp.223;
  const char * D.37346;
  gchar * D.37347;
  void * D.37350;
  struct MonoInst * D.37351;
  long int D.37352;
  struct MonoInst * D.37353;
  guint16 iftmp.224;
  int D.37358;
  int D.37359;
  long int D.37362;
  struct MonoInst * D.37363;
  int D.37364;
  int D.37365;
  int D.37366;
  unsigned int D.37368;
  int D.37369;
  void * D.37373;
  struct MonoInst * D.37374;
  long int D.37375;
  struct MonoInst * D.37376;
  guint16 iftmp.225;
  int D.37381;
  int D.37382;
  long int D.37385;
  struct MonoInst * D.37386;
  int D.37387;
  int D.37388;
  int D.37389;
  unsigned int D.37391;
  int D.37392;
  void * D.37396;
  struct MonoInst * D.37397;
  long int D.37398;
  struct MonoInst * D.37399;
  int D.37400;
  int D.37401;
  mgreg_t iftmp.226;
  unsigned int D.37406;
  int D.37407;
  struct MonoMethodSignature * D.37415;
  struct MonoInst * * sp.227;
  struct MonoInst * D.37420;
  struct MonoInst * * sp.228;
  struct MonoInst * iftmp.229;
  unsigned int D.37427;
  long unsigned int D.37430;
  long unsigned int D.37431;
  struct MonoInst * * D.37432;
  struct MonoClass * D.37437;
  _Bool D.37438;
  long int D.37439;
  long int D.37440;
  unsigned char D.37443;
  unsigned char D.37444;
  unsigned int D.37445;
  int D.37446;
  struct MonoType * D.37449;
  int D.37450;
  struct MonoInst * iftmp.230;
  int D.37456;
  int D.37457;
  unsigned int D.37458;
  sizetype D.37461;
  sizetype D.37462;
  sizetype D.37463;
  struct MonoInst * * D.37464;
  struct MonoInst * iftmp.231;
  int D.37467;
  unsigned int D.37468;
  sizetype D.37471;
  sizetype D.37472;
  struct MonoInst * * D.37473;
  _Bool D.37475;
  long int D.37476;
  long int D.37477;
  _Bool D.37480;
  long int D.37481;
  long int D.37482;
  unsigned char D.37485;
  unsigned char D.37486;
  unsigned char D.37487;
  unsigned char D.37488;
  int D.37494;
  const char * D.37499;
  gchar * D.37500;
  struct MonoInst * * sp.232;
  struct MonoInst * D.37504;
  long int D.37508;
  struct MonoInst * D.37509;
  int D.37510;
  int D.37511;
  long int D.37515;
  struct MonoInst * D.37516;
  int D.37517;
  int D.37518;
  unsigned int D.37522;
  int D.37523;
  int D.37526;
  struct MonoClass * D.37534;
  struct MonoInst * * sp.233;
  long int D.37539;
  struct MonoInst * D.37540;
  int D.37541;
  int D.37542;
  long int D.37546;
  struct MonoInst * D.37547;
  int D.37548;
  int D.37549;
  int D.37554;
  unsigned int D.37557;
  int D.37558;
  long int D.37562;
  struct MonoInst * D.37563;
  unsigned int D.37564;
  short unsigned int D.37565;
  int D.37566;
  int D.37567;
  unsigned char D.37568;
  <unnamed type> D.37569;
  unsigned int D.37570;
  int D.37571;
  unsigned int D.37576;
  short unsigned int D.37577;
  unsigned int D.37578;
  int D.37579;
  unsigned char D.37583;
  unsigned char D.37584;
  unsigned char D.37587;
  struct MonoInst * * sp.234;
  short unsigned int D.37591;
  int D.37592;
  int D.37593;
  struct MonoDebugOptions * D.37600;
  int D.37601;
  struct MonoDebugOptions * D.37610;
  int D.37611;
  union mono_mutex_t * D.37613;
  _Bool D.37616;
  long int D.37617;
  long int D.37618;
  struct GHashTable * D.37621;
  _Bool D.37626;
  long int D.37627;
  long int D.37628;
  long unsigned int addr.235;
  long unsigned int D.37635;
  const char * D.37646;
  gchar * D.37647;
  unsigned int D.37653;
  long int D.37654;
  struct MonoInst * D.37655;
  int D.37656;
  int D.37657;
  int D.37658;
  guint16 iftmp.236;
  long int D.37670;
  struct MonoInst * D.37671;
  int D.37672;
  int D.37673;
  int D.37674;
  unsigned int D.37676;
  int D.37677;
  long int D.37681;
  struct MonoInst * D.37682;
  int D.37683;
  int D.37684;
  unsigned int D.37688;
  long int D.37689;
  struct MonoInst * D.37690;
  int D.37691;
  int D.37692;
  long int D.37696;
  struct MonoInst * D.37697;
  int D.37698;
  int D.37699;
  long int D.37703;
  struct MonoInst * D.37704;
  int D.37705;
  int D.37706;
  long int D.37710;
  struct MonoInst * D.37711;
  int D.37712;
  int D.37713;
  unsigned int D.37717;
  long int D.37718;
  struct MonoInst * D.37719;
  int D.37720;
  int D.37721;
  unsigned int D.37725;
  long int D.37726;
  struct MonoInst * D.37727;
  int D.37728;
  int D.37729;
  unsigned int D.37733;
  long int addr.237;
  unsigned int D.37739;
  unsigned int D.37740;
  unsigned int D.37741;
  unsigned int D.37742;
  long int D.37743;
  struct MonoInst * D.37744;
  int D.37745;
  int D.37746;
  long unsigned int D.37747;
  long unsigned int D.37748;
  long int D.37749;
  unsigned int D.37753;
  long int D.37754;
  long int D.37755;
  _Bool D.37766;
  long int D.37767;
  long int D.37768;
  void * D.37775;
  struct MonoInst * D.37776;
  long int D.37777;
  struct MonoInst * D.37778;
  int D.37779;
  int D.37780;
  long int D.37781;
  long unsigned int D.37782;
  long unsigned int D.37783;
  struct MonoInst * * D.37784;
  struct MonoInst * D.37785;
  struct MonoType * D.37786;
  unsigned int D.37787;
  short unsigned int D.37788;
  struct MonoClass * D.37789;
  int D.37790;
  unsigned char D.37791;
  <unnamed type> D.37792;
  unsigned int D.37793;
  int D.37794;
  short unsigned int D.37795;
  struct MonoClass * D.37798;
  void * D.37799;
  unsigned int D.37800;
  int D.37801;
  struct MonoInst * D.37807;
  void * D.37809;
  struct MonoInst * D.37810;
  long int D.37811;
  struct MonoInst * D.37812;
  guint16 iftmp.238;
  int D.37817;
  int D.37818;
  long int D.37821;
  struct MonoInst * D.37822;
  int D.37823;
  int D.37824;
  int D.37825;
  unsigned int D.37827;
  int D.37828;
  int D.37834;
  int D.37837;
  unsigned int D.37840;
  int D.37841;
  int D.37842;
  unsigned int D.37850;
  long int D.37851;
  void * D.37867;
  struct MonoInst * D.37868;
  long int D.37869;
  struct MonoInst * D.37870;
  int D.37871;
  int D.37872;
  long int D.37873;
  long unsigned int D.37874;
  long unsigned int D.37875;
  struct MonoInst * * D.37876;
  struct MonoInst * D.37877;
  struct MonoType * D.37878;
  unsigned int D.37879;
  short unsigned int D.37880;
  struct MonoClass * D.37881;
  int D.37882;
  unsigned char D.37883;
  <unnamed type> D.37884;
  unsigned int D.37885;
  int D.37886;
  short unsigned int D.37887;
  struct MonoClass * D.37890;
  void * D.37891;
  unsigned int D.37892;
  int D.37893;
  void * D.37897;
  struct MonoInst * D.37898;
  long int D.37899;
  struct MonoInst * D.37900;
  guint16 iftmp.239;
  int D.37905;
  int D.37906;
  long int D.37909;
  struct MonoInst * D.37910;
  int D.37911;
  int D.37912;
  int D.37913;
  unsigned int D.37915;
  int D.37916;
  struct MonoDebugOptions * D.37925;
  int D.37926;
  int D.37930;
  struct GSList * D.37933;
  const char * D.37938;
  const char * D.37939;
  const char * D.37940;
  long unsigned int D.37942;
  _Bool D.37945;
  long int D.37946;
  long int D.37947;
  long unsigned int D.37950;
  long unsigned int D.37951;
  guint16 iftmp.240;
  long int D.37970;
  struct MonoInst * D.37971;
  int D.37972;
  int D.37973;
  int D.37974;
  unsigned int D.37976;
  int D.37977;
  void * D.37984;
  sizetype D.37985;
  _Bool D.37986;
  long int D.37987;
  long int D.37988;
  unsigned int D.37991;
  int D.37992;
  void * D.37997;
  struct MonoInst * D.37998;
  long int D.37999;
  struct MonoInst * D.38000;
  int D.38001;
  int D.38002;
  unsigned int D.38003;
  long int D.38004;
  unsigned int D.38005;
  int D.38006;
  struct MonoClass * D.38012;
  struct MonoInst * * sp.241;
  long int D.38017;
  struct MonoInst * D.38018;
  unsigned int D.38019;
  short unsigned int D.38020;
  int D.38021;
  int D.38022;
  int D.38023;
  struct MonoClass * D.38024;
  unsigned char D.38028;
  unsigned char D.38029;
  struct MonoDebugOptions * D.38036;
  int D.38037;
  int D.38041;
  long unsigned int D.38048;
  long unsigned int D.38049;
  unsigned char D.38050;
  void * D.38053;
  struct MonoClass * D.38056;
  long unsigned int D.38057;
  long unsigned int D.38058;
  struct MonoType * D.38061;
  unsigned char D.38062;
  const char * D.38065;
  gchar * D.38066;
  void * D.38069;
  unsigned char D.38070;
  long int D.38071;
  unsigned int D.38072;
  int D.38073;
  void * D.38077;
  signed char D.38078;
  long int D.38079;
  unsigned int D.38080;
  int D.38081;
  void * D.38085;
  short unsigned int D.38086;
  long int D.38087;
  unsigned int D.38088;
  int D.38089;
  void * D.38093;
  short int D.38094;
  long int D.38095;
  unsigned int D.38096;
  int D.38097;
  void * D.38101;
  int D.38102;
  long int D.38103;
  unsigned int D.38104;
  int D.38105;
  void * D.38109;
  unsigned int D.38110;
  long int D.38111;
  unsigned int D.38112;
  int D.38113;
  void * D.38117;
  void * D.38118;
  unsigned int D.38119;
  int D.38120;
  int D.38124;
  void * D.38127;
  unsigned int D.38128;
  int D.38129;
  void * D.38134;
  unsigned int D.38135;
  int D.38136;
  long int D.38137;
  struct MonoDebugOptions * D.38149;
  int D.38150;
  long int D.38152;
  struct MonoInst * D.38153;
  unsigned int D.38154;
  short unsigned int D.38155;
  int D.38156;
  int D.38157;
  unsigned char D.38158;
  <unnamed type> D.38159;
  unsigned int D.38160;
  int D.38161;
  unsigned char D.38165;
  unsigned char D.38166;
  struct MonoInst * * sp.242;
  struct MonoDebugOptions * D.38174;
  int D.38175;
  struct MonoDebugOptions * D.38183;
  int D.38184;
  struct MonoClass * klass.243;
  struct MonoDebugOptions * D.38190;
  int D.38191;
  unsigned int D.38193;
  short unsigned int D.38194;
  struct MonoClass * D.38195;
  int D.38203;
  struct MonoDebugOptions * D.38212;
  int D.38213;
  struct MonoDebugOptions * D.38221;
  int D.38222;
  struct MonoClass * klass.244;
  struct MonoDebugOptions * D.38228;
  int D.38229;
  unsigned char D.38231;
  unsigned int D.38234;
  int D.38235;
  struct MonoInst * D.38239;
  struct MonoInst * D.38242;
  void * D.38253;
  struct MonoInst * D.38254;
  long int D.38255;
  struct MonoInst * D.38256;
  int D.38257;
  int D.38258;
  long int D.38259;
  long unsigned int D.38260;
  long unsigned int D.38261;
  struct MonoInst * * D.38262;
  struct MonoInst * D.38263;
  struct MonoType * D.38264;
  unsigned int D.38265;
  short unsigned int D.38266;
  struct MonoClass * D.38267;
  int D.38268;
  unsigned char D.38269;
  <unnamed type> D.38270;
  unsigned int D.38271;
  int D.38272;
  short unsigned int D.38273;
  struct MonoClass * D.38276;
  void * D.38277;
  unsigned int D.38278;
  int D.38279;
  void * D.38283;
  struct MonoInst * D.38284;
  long int D.38285;
  struct MonoInst * D.38286;
  guint16 iftmp.245;
  int D.38291;
  int D.38292;
  long int D.38295;
  struct MonoInst * D.38296;
  int D.38297;
  int D.38298;
  int D.38299;
  unsigned int D.38301;
  int D.38302;
  unsigned char D.38310;
  struct MonoDebugOptions * D.38311;
  int D.38312;
  unsigned int D.38314;
  int D.38315;
  unsigned int D.38319;
  struct MonoInst * * sp.246;
  const guint8 * D.38325;
  int D.38326;
  short unsigned int D.38329;
  long int D.38332;
  unsigned int D.38333;
  unsigned int D.38336;
  void * D.38337;
  struct MonoInst * D.38338;
  long int D.38339;
  struct MonoInst * D.38340;
  int D.38341;
  int D.38342;
  void * D.38348;
  struct MonoInst * D.38349;
  long int D.38350;
  struct MonoInst * D.38351;
  int D.38352;
  int D.38353;
  long int D.38354;
  struct MonoInst * D.38355;
  int D.38356;
  int D.38357;
  unsigned int field_token.247;
  struct MonoJumpInfoToken * D.38359;
  int D.38360;
  unsigned int D.38361;
  int D.38362;
  void * D.38367;
  unsigned int D.38368;
  int D.38369;
  void * D.38373;
  struct MonoInst * D.38374;
  long int D.38375;
  struct MonoInst * D.38376;
  int D.38377;
  int D.38378;
  int data_size.248;
  long int D.38380;
  unsigned int D.38381;
  int D.38382;
  struct MonoDebugOptions * D.38392;
  int D.38393;
  struct MonoDebugOptions * D.38401;
  int D.38402;
  unsigned int D.38404;
  int D.38405;
  unsigned char D.38406;
  struct MonoInst * * sp.249;
  struct MonoDebugOptions * D.38417;
  int D.38418;
  struct MonoDebugOptions * D.38426;
  int D.38427;
  struct MonoDebugOptions * D.38435;
  int D.38436;
  unsigned int D.38438;
  struct MonoClass * klass.250;
  struct MonoDebugOptions * D.38443;
  int D.38444;
  unsigned char D.38455;
  struct MonoDebugOptions * D.38456;
  int D.38457;
  struct MonoInst * * sp.251;
  struct MonoDebugOptions * D.38466;
  int D.38467;
  struct MonoDebugOptions * D.38477;
  int D.38478;
  struct MonoClass * klass.252;
  struct MonoDebugOptions * D.38484;
  int D.38485;
  struct MonoClass * klass.253;
  struct MonoDebugOptions * D.38495;
  int D.38496;
  int D.38498;
  unsigned int D.38501;
  short unsigned int D.38502;
  int D.38503;
  unsigned int D.38504;
  int D.38505;
  int D.38512;
  unsigned int D.38513;
  unsigned int D.38514;
  unsigned int D.38515;
  unsigned int D.38516;
  unsigned int D.38517;
  unsigned int D.38520;
  long int D.38525;
  struct MonoInst * D.38526;
  int D.38527;
  int D.38528;
  long int D.38532;
  struct MonoInst * D.38533;
  int D.38534;
  int D.38535;
  unsigned int D.38542;
  int D.38545;
  long int D.38550;
  struct MonoInst * D.38551;
  int D.38552;
  int D.38553;
  long int D.38557;
  struct MonoInst * D.38558;
  int D.38559;
  int D.38560;
  long int D.38565;
  struct MonoInst * D.38566;
  int D.38567;
  int D.38568;
  unsigned char D.38569;
  int D.38574;
  long int D.38579;
  struct MonoInst * D.38580;
  int D.38581;
  int D.38582;
  long int D.38586;
  struct MonoInst * D.38587;
  int D.38588;
  int D.38589;
  long int D.38594;
  struct MonoInst * D.38595;
  int D.38596;
  int D.38597;
  unsigned char D.38598;
  long int D.38602;
  struct MonoInst * D.38603;
  int D.38604;
  int D.38605;
  long int D.38609;
  struct MonoInst * D.38610;
  int D.38611;
  int D.38612;
  unsigned int D.38617;
  int D.38620;
  long int D.38625;
  struct MonoInst * D.38626;
  int D.38627;
  int D.38628;
  long int D.38632;
  struct MonoInst * D.38633;
  int D.38634;
  int D.38635;
  long int D.38640;
  struct MonoInst * D.38641;
  int D.38642;
  int D.38643;
  unsigned char D.38644;
  int D.38649;
  long int D.38654;
  struct MonoInst * D.38655;
  int D.38656;
  int D.38657;
  long int D.38661;
  struct MonoInst * D.38662;
  int D.38663;
  int D.38664;
  long int D.38669;
  struct MonoInst * D.38670;
  int D.38671;
  int D.38672;
  unsigned char D.38673;
  long int D.38677;
  struct MonoInst * D.38678;
  int D.38679;
  int D.38680;
  long int D.38684;
  struct MonoInst * D.38685;
  int D.38686;
  int D.38687;
  long int D.38692;
  struct MonoInst * D.38693;
  int D.38694;
  int D.38695;
  unsigned char D.38696;
  unsigned char D.38697;
  unsigned int D.38701;
  short unsigned int D.38702;
  long int D.38703;
  unsigned int D.38704;
  int D.38705;
  unsigned int D.38710;
  short unsigned int D.38711;
  unsigned int D.38712;
  int D.38713;
  struct MonoInst * * sp.254;
  struct MonoDebugOptions * D.38727;
  int D.38728;
  struct MonoDebugOptions * D.38738;
  int D.38739;
  struct MonoClass * klass.255;
  struct MonoDebugOptions * D.38745;
  int D.38746;
  struct MonoClass * klass.256;
  struct MonoDebugOptions * D.38756;
  int D.38757;
  struct MonoDebugOptions * D.38768;
  int D.38769;
  unsigned int D.38771;
  int D.38772;
  struct MonoInst * * sp.257;
  struct MonoInst * D.38777;
  unsigned int D.38778;
  unsigned int D.38779;
  const char * D.38782;
  gchar * D.38783;
  struct MonoDebugOptions * D.38792;
  int D.38793;
  struct MonoDebugOptions * D.38801;
  int D.38802;
  struct MonoClass * klass.258;
  struct MonoDebugOptions * D.38808;
  int D.38809;
  struct MonoInst * iftmp.259;
  struct MonoClass * D.38817;
  struct MonoType * D.38818;
  long int D.38819;
  struct MonoInst * D.38820;
  int D.38821;
  int D.38822;
  unsigned char D.38823;
  unsigned char D.38824;
  struct MonoClass * D.38825;
  unsigned int D.38826;
  int D.38827;
  struct MonoType * D.38830;
  int D.38831;
  struct MonoInst * iftmp.260;
  int D.38837;
  int D.38838;
  unsigned int D.38839;
  sizetype D.38842;
  sizetype D.38843;
  sizetype D.38844;
  struct MonoInst * * D.38845;
  struct MonoInst * iftmp.261;
  int D.38848;
  unsigned int D.38849;
  sizetype D.38852;
  sizetype D.38853;
  struct MonoInst * * D.38854;
  _Bool D.38856;
  long int D.38857;
  long int D.38858;
  _Bool D.38861;
  long int D.38862;
  long int D.38863;
  unsigned char D.38866;
  unsigned char D.38867;
  unsigned char D.38868;
  unsigned char D.38869;
  long int D.38873;
  struct MonoInst * D.38874;
  int D.38875;
  int D.38876;
  int D.38877;
  long int D.38883;
  struct MonoInst * D.38884;
  int D.38885;
  int D.38886;
  int D.38887;
  long int D.38891;
  struct MonoInst * D.38892;
  int D.38893;
  int D.38894;
  struct MonoInst * * sp.262;
  const char * D.38905;
  gchar * D.38906;
  struct MonoDebugOptions * D.38915;
  int D.38916;
  struct MonoDebugOptions * D.38924;
  int D.38925;
  struct MonoClass * klass.263;
  struct MonoDebugOptions * D.38931;
  int D.38932;
  long int D.38934;
  struct MonoInst * D.38935;
  int D.38936;
  int D.38937;
  long int D.38938;
  long unsigned int D.38939;
  long unsigned int D.38940;
  struct MonoInst * * D.38941;
  struct MonoInst * D.38942;
  unsigned char D.38943;
  unsigned char D.38944;
  struct MonoClass * D.38945;
  unsigned int D.38946;
  int D.38947;
  struct MonoType * D.38950;
  int D.38951;
  struct MonoInst * iftmp.264;
  int D.38957;
  int D.38958;
  unsigned int D.38959;
  sizetype D.38962;
  sizetype D.38963;
  sizetype D.38964;
  struct MonoInst * * D.38965;
  struct MonoInst * iftmp.265;
  int D.38968;
  unsigned int D.38969;
  sizetype D.38972;
  sizetype D.38973;
  struct MonoInst * * D.38974;
  _Bool D.38976;
  long int D.38977;
  long int D.38978;
  _Bool D.38981;
  long int D.38982;
  long int D.38983;
  unsigned char D.38986;
  unsigned char D.38987;
  unsigned char D.38988;
  unsigned char D.38989;
  unsigned int D.38995;
  long int D.38996;
  struct MonoInst * D.38997;
  int D.38998;
  int D.38999;
  int D.39000;
  int D.39001;
  long int D.39005;
  struct MonoInst * D.39006;
  int D.39007;
  int D.39008;
  long int D.39012;
  struct MonoInst * D.39013;
  int D.39014;
  int D.39015;
  unsigned int D.39022;
  unsigned int D.39023;
  long int D.39024;
  struct MonoInst * D.39025;
  guint16 iftmp.266;
  int D.39030;
  int D.39031;
  long int D.39034;
  struct MonoInst * D.39035;
  int D.39036;
  int D.39037;
  int D.39038;
  unsigned int D.39040;
  int D.39041;
  long int D.39045;
  struct MonoInst * D.39046;
  int D.39047;
  int D.39048;
  long int D.39052;
  struct MonoInst * D.39053;
  int D.39054;
  int D.39055;
  long int D.39059;
  struct MonoInst * D.39060;
  int D.39061;
  int D.39062;
  long int D.39067;
  struct MonoInst * D.39068;
  int D.39069;
  int D.39070;
  long int D.39071;
  long int D.39075;
  struct MonoInst * D.39076;
  int D.39077;
  int D.39078;
  long int klass.267;
  long int D.39083;
  struct MonoInst * D.39084;
  int D.39085;
  int D.39086;
  unsigned int D.39090;
  short unsigned int D.39091;
  unsigned int D.39092;
  int D.39093;
  struct MonoClass * D.39096;
  struct MonoInst * * sp.268;
  struct MonoDebugOptions * D.39107;
  int D.39108;
  struct MonoDebugOptions * D.39116;
  int D.39117;
  int D.39123;
  unsigned int D.39124;
  void * handle_class.269;
  struct MonoClass * D.39126;
  struct MonoClass * handle_class.270;
  struct MonoDebugOptions * D.39132;
  int D.39133;
  int D.39137;
  unsigned int D.39138;
  unsigned int D.39139;
  int D.39145;
  struct MonoClass * D.39149;
  struct MonoClass * D.39151;
  struct MonoClass * D.39154;
  struct MonoClass * D.39156;
  struct MonoType * D.39165;
  void * D.39166;
  struct MonoInst * D.39167;
  long int D.39168;
  struct MonoInst * D.39169;
  guint16 iftmp.271;
  int D.39174;
  int D.39175;
  long int D.39178;
  struct MonoInst * D.39179;
  int D.39180;
  int D.39181;
  int D.39182;
  unsigned int D.39184;
  int D.39185;
  void * D.39189;
  struct MonoInst * D.39190;
  long int D.39191;
  struct MonoInst * D.39192;
  int D.39193;
  int D.39194;
  long int D.39195;
  unsigned int D.39196;
  int D.39197;
  struct MonoInst * D.39203;
  void * D.39205;
  struct MonoInst * D.39206;
  long int D.39207;
  struct MonoInst * D.39208;
  int D.39209;
  int D.39210;
  unsigned int D.39211;
  int D.39212;
  long int D.39216;
  struct MonoInst * D.39217;
  int D.39218;
  int D.39219;
  long int D.39220;
  long unsigned int D.39221;
  long unsigned int D.39222;
  struct MonoInst * * D.39223;
  struct MonoInst * D.39224;
  unsigned char D.39225;
  unsigned char D.39226;
  struct MonoClass * D.39227;
  unsigned int D.39228;
  int D.39229;
  struct MonoType * D.39232;
  int D.39233;
  struct MonoInst * iftmp.272;
  int D.39239;
  int D.39240;
  unsigned int D.39241;
  sizetype D.39244;
  sizetype D.39245;
  sizetype D.39246;
  struct MonoInst * * D.39247;
  struct MonoInst * iftmp.273;
  int D.39250;
  unsigned int D.39251;
  sizetype D.39254;
  sizetype D.39255;
  struct MonoInst * * D.39256;
  _Bool D.39258;
  long int D.39259;
  long int D.39260;
  _Bool D.39263;
  long int D.39264;
  long int D.39265;
  unsigned char D.39268;
  unsigned char D.39269;
  unsigned char D.39270;
  unsigned char D.39271;
  long int D.39275;
  struct MonoInst * D.39276;
  int D.39277;
  int D.39278;
  int D.39279;
  unsigned int D.39283;
  short unsigned int D.39284;
  unsigned int D.39285;
  int D.39286;
  struct MonoClass * D.39289;
  int D.39297;
  struct MonoClass * D.39301;
  int D.28569;
  int iftmp.274;
  int D.28568;
  const char[18] * D.39306;
  unsigned char D.39307;
  int D.39308;
  unsigned char D.39309;
  int D.39310;
  const unsigned char * D.39315;
  unsigned char D.39316;
  int D.39317;
  const unsigned char * D.39318;
  unsigned char D.39319;
  int D.39320;
  const unsigned char * D.39325;
  unsigned char D.39326;
  int D.39327;
  const unsigned char * D.39328;
  unsigned char D.39329;
  int D.39330;
  const unsigned char * D.39335;
  unsigned char D.39336;
  int D.39337;
  const unsigned char * D.39338;
  unsigned char D.39339;
  int D.39340;
  struct MonoImage * D.39352;
  unsigned int D.39353;
  struct MonoClass * D.39354;
  long int D.39357;
  struct MonoInst * D.39358;
  int D.39359;
  int D.39360;
  struct MonoJumpInfoToken * D.39361;
  int D.39362;
  struct MonoClass * D.39363;
  unsigned int D.39364;
  int D.39365;
  unsigned int D.39371;
  int D.39372;
  long int D.39377;
  struct MonoInst * D.39378;
  int D.39379;
  int D.39380;
  struct MonoJumpInfoToken * D.39381;
  int D.39382;
  unsigned int D.39383;
  int D.39384;
  struct MonoReflectionType * D.39389;
  unsigned int D.39390;
  int D.39391;
  struct MonoClass * D.39399;
  long int D.39410;
  struct MonoInst * D.39411;
  int D.39412;
  int D.39413;
  struct MonoJumpInfoToken * D.39414;
  int D.39415;
  unsigned int D.39416;
  int D.39417;
  unsigned int D.39422;
  int D.39423;
  long int D.39427;
  struct MonoInst * D.39428;
  int D.39429;
  int D.39430;
  long int D.39431;
  long unsigned int D.39432;
  long unsigned int D.39433;
  struct MonoInst * * D.39434;
  struct MonoInst * D.39435;
  unsigned char D.39436;
  unsigned char D.39437;
  struct MonoClass * D.39438;
  unsigned int D.39439;
  int D.39440;
  struct MonoType * D.39443;
  int D.39444;
  struct MonoInst * iftmp.275;
  int D.39450;
  int D.39451;
  unsigned int D.39452;
  sizetype D.39455;
  sizetype D.39456;
  sizetype D.39457;
  struct MonoInst * * D.39458;
  struct MonoInst * iftmp.276;
  int D.39461;
  unsigned int D.39462;
  sizetype D.39465;
  sizetype D.39466;
  struct MonoInst * * D.39467;
  _Bool D.39469;
  long int D.39470;
  long int D.39471;
  _Bool D.39474;
  long int D.39475;
  long int D.39476;
  unsigned char D.39479;
  unsigned char D.39480;
  unsigned char D.39481;
  unsigned char D.39482;
  long int D.39486;
  struct MonoInst * D.39487;
  int D.39488;
  int D.39489;
  int D.39490;
  unsigned int D.39494;
  short unsigned int D.39495;
  unsigned int D.39496;
  int D.39497;
  struct MonoClass * D.39500;
  struct MonoInst * * sp.277;
  struct MonoDebugOptions * D.39511;
  int D.39512;
  struct MonoDebugOptions * D.39533;
  int D.39534;
  sizetype D.39536;
  sizetype D.39537;
  struct MonoDebugOptions * D.39545;
  int D.39546;
  signed char D.39548;
  sizetype D.39549;
  sizetype D.39550;
  unsigned int D.39551;
  long int D.39552;
  unsigned int D.39555;
  unsigned int D.39556;
  long int D.39557;
  unsigned int D.39560;
  long int iftmp.278;
  long int D.39567;
  unsigned int D.39572;
  unsigned int D.39573;
  int D.39574;
  long int D.39575;
  struct MonoInst * D.39576;
  int D.39577;
  int D.39578;
  int D.39579;
  long int D.39583;
  struct MonoInst * D.39584;
  int D.39585;
  int D.39586;
  unsigned int D.39589;
  unsigned int D.39590;
  int D.39591;
  unsigned char * D.39595;
  long int D.39598;
  long int D.39599;
  long unsigned int D.39600;
  long unsigned int D.39601;
  struct MonoBasicBlock * * D.39602;
  void * D.39618;
  struct MonoBasicBlock * * D.39619;
  struct MonoBasicBlock * * D.39620;
  unsigned int D.39626;
  unsigned int D.39627;
  int D.39628;
  long int D.39646;
  struct MonoInst * D.39647;
  int D.39648;
  int D.39649;
  unsigned char * D.39653;
  long int D.39656;
  long int D.39657;
  long unsigned int D.39658;
  long unsigned int D.39659;
  struct MonoBasicBlock * * D.39660;
  unsigned int D.39677;
  long unsigned int D.39678;
  long unsigned int D.39679;
  struct MonoBasicBlock * * D.39680;
  _Bool D.39681;
  long int D.39682;
  long int D.39683;
  struct MonoDebugOptions * D.39700;
  int D.39701;
  unsigned int D.39703;
  unsigned int D.39704;
  int D.39705;
  unsigned char * D.39706;
  long int D.39709;
  long int D.39710;
  long unsigned int D.39711;
  long unsigned int D.39712;
  struct MonoBasicBlock * * D.39713;
  struct MonoDebugOptions * D.39726;
  int D.39727;
  unsigned int D.39729;
  unsigned int D.39730;
  int D.39731;
  _Bool D.39737;
  long int D.39738;
  long int D.39739;
  struct MonoDebugOptions * D.39748;
  int D.39749;
  char * D.39753;
  _Bool D.39754;
  long int D.39755;
  long int D.39756;
  struct MonoMethodSignature * D.39759;
  short unsigned int D.39760;
  long int D.39761;
  struct MonoDebugOptions * D.39768;
  int D.39769;
  long unsigned int D.39771;
  long unsigned int D.39772;
  sizetype D.39773;
  const void * D.39774;
  struct MonoType * D.39775;
  int D.39776;
  struct MonoInst * * sp.279;
  int num_calls.280;
  int D.39781;
  struct MonoDebugOptions * D.39788;
  int D.39789;
  struct MonoDebugOptions * D.39797;
  int D.39798;
  gint32 * D.39802;
  guint16 iftmp.281;
  long int D.39811;
  struct MonoInst * D.39812;
  int D.39813;
  int D.39814;
  int D.39815;
  unsigned int D.39817;
  int D.39818;
  struct MonoInst * * sp.282;
  unsigned int D.39823;
  int D.39824;
  struct MonoInst * * sp.283;
  int num_calls.284;
  int D.39830;
  struct MonoDebugOptions * D.39839;
  int D.39840;
  struct MonoDebugOptions * D.39848;
  int D.39849;
  _Bool D.39851;
  long int D.39852;
  long int D.39853;
  guint16 iftmp.285;
  long int D.39862;
  struct MonoInst * D.39863;
  int D.39864;
  int D.39865;
  const char * D.39866;
  int D.39867;
  unsigned int D.39869;
  int D.39870;
  struct MonoInst * * sp.286;
  int num_calls.287;
  int D.39876;
  struct MonoDebugOptions * D.39883;
  int D.39884;
  struct MonoDebugOptions * D.39892;
  int D.39893;
  guint16 iftmp.288;
  long int D.39903;
  struct MonoInst * D.39904;
  int D.39905;
  int D.39906;
  int D.39907;
  unsigned int D.39909;
  int D.39910;
  _Bool D.39915;
  long int D.39916;
  long int D.39917;
  unsigned int D.39920;
  int D.39921;
  struct MonoInst * * sp.289;
  struct MonoDebugOptions * D.39932;
  int D.39933;
  struct MonoInst * iftmp.290;
  long int D.39939;
  struct MonoInst * D.39940;
  int D.39941;
  int D.39942;
  unsigned char D.39943;
  unsigned char D.39944;
  struct MonoClass * D.39945;
  unsigned int D.39946;
  int D.39947;
  struct MonoType * D.39950;
  int D.39951;
  struct MonoInst * iftmp.291;
  int D.39957;
  int D.39958;
  unsigned int D.39959;
  sizetype D.39962;
  sizetype D.39963;
  sizetype D.39964;
  struct MonoInst * * D.39965;
  struct MonoInst * iftmp.292;
  int D.39968;
  unsigned int D.39969;
  sizetype D.39972;
  sizetype D.39973;
  struct MonoInst * * D.39974;
  _Bool D.39976;
  long int D.39977;
  long int D.39978;
  _Bool D.39981;
  long int D.39982;
  long int D.39983;
  unsigned char D.39986;
  unsigned char D.39987;
  unsigned char D.39988;
  unsigned char D.39989;
  struct MonoInst * * sp.293;
  struct MonoDebugOptions * D.40000;
  int D.40001;
  struct MonoDebugOptions * D.40009;
  int D.40010;
  void * klass.294;
  void * D.40017;
  struct MonoInst * D.40018;
  long int D.40019;
  struct MonoInst * D.40020;
  int D.40021;
  int D.40022;
  long int D.40023;
  long unsigned int D.40024;
  long unsigned int D.40025;
  struct MonoInst * * D.40026;
  struct MonoInst * D.40027;
  struct MonoType * D.40028;
  unsigned int D.40029;
  short unsigned int D.40030;
  struct MonoClass * D.40031;
  int D.40032;
  unsigned char D.40033;
  <unnamed type> D.40034;
  unsigned int D.40035;
  int D.40036;
  short unsigned int D.40037;
  struct MonoClass * D.40040;
  void * D.40041;
  unsigned int D.40042;
  int D.40043;
  void * D.40047;
  struct MonoInst * D.40048;
  long int D.40049;
  struct MonoInst * D.40050;
  guint16 iftmp.295;
  int D.40055;
  int D.40056;
  long int D.40059;
  struct MonoInst * D.40060;
  int D.40061;
  int D.40062;
  int D.40063;
  unsigned int D.40065;
  int D.40066;
  struct MonoInst * * sp.296;
  struct MonoInst * D.40071;
  int num_calls.297;
  int D.40073;
  struct MonoDebugOptions * D.40080;
  int D.40081;
  unsigned int D.40083;
  int D.40084;
  struct MonoInst * * sp.298;
  struct MonoDebugOptions * D.40095;
  int D.40096;
  struct MonoDebugOptions * D.40104;
  int D.40105;
  void * klass.299;
  _Bool D.40108;
  long int D.40109;
  long int D.40110;
  long int D.40113;
  struct MonoInst * D.40114;
  int D.40115;
  int D.40116;
  long int D.40117;
  long unsigned int D.40118;
  long unsigned int D.40119;
  struct MonoInst * * D.40120;
  struct MonoInst * D.40121;
  unsigned char D.40122;
  unsigned char D.40123;
  struct MonoClass * D.40124;
  unsigned int D.40125;
  int D.40126;
  struct MonoType * D.40129;
  int D.40130;
  struct MonoInst * iftmp.300;
  int D.40136;
  int D.40137;
  unsigned int D.40138;
  sizetype D.40141;
  sizetype D.40142;
  sizetype D.40143;
  struct MonoInst * * D.40144;
  struct MonoInst * iftmp.301;
  int D.40147;
  unsigned int D.40148;
  sizetype D.40151;
  sizetype D.40152;
  struct MonoInst * * D.40153;
  _Bool D.40155;
  long int D.40156;
  long int D.40157;
  _Bool D.40160;
  long int D.40161;
  long int D.40162;
  unsigned char D.40165;
  unsigned char D.40166;
  unsigned char D.40167;
  unsigned char D.40168;
  unsigned int D.40172;
  short unsigned int D.40173;
  unsigned char D.40174;
  <unnamed type> D.40175;
  unsigned int D.40176;
  int D.40177;
  short unsigned int D.40178;
  struct MonoClass * D.40181;
  struct MonoInst * * sp.302;
  _Bool D.40186;
  long int D.40187;
  long int D.40188;
  struct MonoMethodSignature * D.40191;
  long unsigned int D.40192;
  long unsigned int D.40193;
  _Bool D.40194;
  long int D.40195;
  long int D.40196;
  struct MonoDebugOptions * D.40205;
  int D.40206;
  struct MonoDebugOptions * D.40214;
  int D.40215;
  void * klass.303;
  long unsigned int D.40220;
  _Bool D.40221;
  long int D.40222;
  long int D.40223;
  unsigned char D.40226;
  unsigned char D.40227;
  unsigned int D.40228;
  int D.40229;
  struct MonoType * D.40232;
  int D.40233;
  struct MonoInst * iftmp.304;
  int D.40239;
  unsigned int D.40240;
  sizetype D.40243;
  sizetype D.40244;
  sizetype D.40245;
  struct MonoInst * * D.40246;
  struct MonoInst * iftmp.305;
  int D.40249;
  unsigned int D.40250;
  sizetype D.40253;
  sizetype D.40254;
  struct MonoInst * * D.40255;
  _Bool D.40257;
  long int D.40258;
  long int D.40259;
  _Bool D.40262;
  long int D.40263;
  long int D.40264;
  unsigned char D.40267;
  unsigned char D.40268;
  unsigned char D.40269;
  unsigned char D.40270;
  unsigned int D.40275;
  int D.40276;
  struct MonoDebugOptions * D.40286;
  int D.40287;
  struct MonoDebugOptions * D.40298;
  int D.40299;
  struct MonoDebugOptions * D.40307;
  int D.40308;
  const guint32 * D.40310;
  unsigned int D.40311;
  unsigned int token.306;
  void * klass.307;
  struct MonoInst * * sp.308;
  struct MonoDebugOptions * D.40324;
  int D.40325;
  struct MonoDebugOptions * D.40333;
  int D.40334;
  guint16 iftmp.309;
  long int D.40342;
  struct MonoInst * D.40343;
  int D.40344;
  int D.40345;
  void * D.40346;
  int D.40347;
  void * D.40349;
  unsigned int D.40350;
  int D.40351;
  struct MonoInst * * sp.310;
  int num_calls.311;
  int D.40357;
  struct MonoDebugOptions * D.40364;
  int D.40365;
  struct MonoDebugOptions * D.40373;
  int D.40374;
  _Bool D.40376;
  long int D.40377;
  long int D.40378;
  <unnamed type> key.312;
  unsigned int D.40388;
  int D.40389;
  struct MonoInst * * sp.313;
  struct MonoInst * D.40395;
  struct MonoInst * D.40398;
  unsigned char D.40399;
  unsigned char D.40400;
  int D.40401;
  int D.40402;
  unsigned int D.40406;
  int num_calls.314;
  int D.40408;
  struct MonoDebugOptions * D.40415;
  int D.40416;
  struct MonoInst * D.40418;
  unsigned int D.40419;
  int D.40420;
  long int D.40424;
  struct MonoInst * D.40425;
  int D.40426;
  int D.40427;
  struct MonoInst * D.40428;
  int D.40429;
  unsigned int D.40437;
  unsigned int D.40438;
  int D.40439;
  long int D.40443;
  struct MonoInst * D.40444;
  int D.40445;
  int D.40446;
  int D.40447;
  long int D.40451;
  struct MonoInst * D.40452;
  int D.40453;
  int D.40454;
  unsigned int D.40457;
  unsigned int D.40458;
  int D.40459;
  unsigned char * D.40463;
  long int D.40466;
  long int D.40467;
  long unsigned int D.40468;
  long unsigned int D.40469;
  struct MonoBasicBlock * * D.40470;
  void * D.40486;
  struct MonoBasicBlock * * D.40487;
  struct MonoBasicBlock * * D.40488;
  unsigned int D.40494;
  unsigned int D.40495;
  int D.40496;
  long int D.40517;
  struct MonoInst * D.40518;
  int D.40519;
  int D.40520;
  int D.40521;
  long int D.40525;
  struct MonoInst * D.40526;
  int D.40527;
  int D.40528;
  unsigned int D.40531;
  unsigned int D.40532;
  int D.40533;
  unsigned char * D.40537;
  long int D.40540;
  long int D.40541;
  long unsigned int D.40542;
  long unsigned int D.40543;
  struct MonoBasicBlock * * D.40544;
  void * D.40560;
  struct MonoBasicBlock * * D.40561;
  struct MonoBasicBlock * * D.40562;
  unsigned int D.40568;
  unsigned int D.40569;
  int D.40570;
  void * D.40590;
  struct MonoInst * D.40591;
  long int D.40592;
  struct MonoInst * D.40593;
  int D.40594;
  int D.40595;
  unsigned int D.40596;
  int D.40597;
  void * D.40602;
  unsigned int D.40603;
  int D.40604;
  long int D.40608;
  struct MonoInst * D.40609;
  int D.40610;
  int D.40611;
  unsigned char * D.40617;
  long int D.40620;
  long int D.40621;
  long unsigned int D.40622;
  long unsigned int D.40623;
  struct MonoBasicBlock * * D.40624;
  unsigned int D.40639;
  void * D.40640;
  struct MonoInst * D.40641;
  long int D.40642;
  struct MonoInst * D.40643;
  int D.40644;
  int D.40645;
  struct MonoDebugOptions * D.40655;
  int D.40656;
  struct MonoDebugOptions * D.40664;
  int D.40665;
  struct MonoClass * D.40667;
  struct MonoType * D.40668;
  long int D.40669;
  struct MonoInst * D.40670;
  int D.40671;
  int D.40672;
  long int D.40673;
  long unsigned int D.40674;
  long unsigned int D.40675;
  struct MonoInst * * D.40676;
  struct MonoInst * D.40677;
  unsigned char D.40678;
  unsigned char D.40679;
  struct MonoClass * D.40680;
  unsigned int D.40681;
  int D.40682;
  struct MonoType * D.40685;
  int D.40686;
  struct MonoInst * iftmp.315;
  int D.40692;
  int D.40693;
  unsigned int D.40694;
  sizetype D.40697;
  sizetype D.40698;
  sizetype D.40699;
  struct MonoInst * * D.40700;
  struct MonoInst * iftmp.316;
  int D.40703;
  unsigned int D.40704;
  sizetype D.40707;
  sizetype D.40708;
  struct MonoInst * * D.40709;
  _Bool D.40711;
  long int D.40712;
  long int D.40713;
  _Bool D.40716;
  long int D.40717;
  long int D.40718;
  unsigned char D.40721;
  unsigned char D.40722;
  unsigned char D.40723;
  unsigned char D.40724;
  int D.40728;
  unsigned int D.40732;
  short unsigned int D.40733;
  unsigned int D.40734;
  int D.40735;
  struct MonoClass * D.40738;
  struct MonoInst * * sp.317;
  struct MonoDebugOptions * D.40749;
  int D.40750;
  long int D.40752;
  struct MonoInst * D.40753;
  short unsigned int D.40754;
  short unsigned int D.40755;
  int D.40756;
  int D.40757;
  short unsigned int D.40758;
  unsigned char D.40759;
  struct MonoDebugOptions * D.40766;
  int D.40767;
  unsigned int D.40781;
  int D.40782;
  int D.40785;
  struct MonoInst * * sp.318;
  struct MonoDebugOptions * D.40796;
  int D.40797;
  struct MonoDebugOptions * D.40805;
  int D.40806;
  struct MonoLoaderError * D.40811;
  struct MonoDebugOptions * D.40812;
  int D.40813;
  int D.40819;
  gchar * D.40822;
  <unnamed type> D.40823;
  int D.40826;
  <unnamed type> D.40837;
  unsigned char * D.40842;
  int D.40845;
  const guint32 * D.40850;
  unsigned int D.40851;
  struct MonoClass * D.40854;
  struct MonoClass * D.40855;
  struct MonoMethodSignature * D.40861;
  struct MonoDebugOptions * D.40862;
  int D.40863;
  <unnamed type> D.40865;
  int D.40868;
  struct MonoMethodSignature * D.40871;
  short unsigned int D.40872;
  struct MonoMethodSignature * D.40873;
  short unsigned int D.40874;
  long int D.40877;
  struct MonoInst * D.40878;
  int D.40879;
  int D.40880;
  int D.40881;
  long int D.40885;
  struct MonoInst * D.40886;
  int D.40887;
  int D.40888;
  char * D.40896;
  struct MonoInst * D.40897;
  struct MonoInst * argconst.319;
  struct MonoInst * * sp.320;
  int num_calls.321;
  int D.40902;
  struct MonoDebugOptions * D.40909;
  int D.40910;
  struct MonoDebugOptions * D.40918;
  int D.40919;
  struct MonoLoaderError * D.40924;
  struct MonoDebugOptions * D.40925;
  int D.40926;
  <unnamed type> D.40928;
  int D.40931;
  <unnamed type> D.40942;
  struct MonoInst * D.40945;
  struct MonoInst * * sp.322;
  struct MonoInst * D.40949;
  struct MonoInst * * sp.323;
  struct MonoInst * D.40952;
  int num_calls.324;
  int D.40954;
  struct MonoDebugOptions * D.40961;
  int D.40962;
  unsigned char * D.40964;
  struct MonoDebugOptions * D.40971;
  int D.40972;
  const guint16 * D.40974;
  short unsigned int D.40975;
  struct MonoDebugOptions * D.40982;
  int D.40983;
  unsigned int D.40985;
  short unsigned int D.40986;
  unsigned int D.40987;
  int D.40988;
  struct MonoClass * D.40991;
  struct MonoInst * * sp.325;
  struct MonoDebugOptions * D.41002;
  int D.41003;
  struct MonoDebugOptions * D.41011;
  int D.41012;
  struct MonoDebugOptions * D.41020;
  int D.41021;
  unsigned int D.41023;
  int D.41024;
  int D.41027;
  struct MonoInst * iftmp.326;
  struct MonoInst * iftmp.327;
  _Bool D.41040;
  long int D.41041;
  long int D.41042;
  _Bool D.41045;
  long int D.41046;
  long int D.41047;
  unsigned char D.41050;
  unsigned char D.41051;
  unsigned char D.41052;
  unsigned char D.41053;
  struct MonoInst * * sp.328;
  struct MonoDebugOptions * D.41064;
  int D.41065;
  struct MonoDebugOptions * D.41073;
  int D.41074;
  struct MonoDebugOptions * D.41082;
  int D.41083;
  struct MonoType * * D.41087;
  struct MonoType * D.41088;
  int D.41089;
  struct MonoDebugOptions * D.41096;
  int D.41097;
  unsigned int D.41099;
  short unsigned int D.41100;
  struct MonoClass * D.41103;
  struct MonoDebugOptions * D.41113;
  int D.41114;
  struct MonoDebugOptions * D.41122;
  int D.41123;
  struct MonoDebugOptions * D.41131;
  int D.41132;
  unsigned int D.41134;
  short unsigned int D.41135;
  unsigned int D.41136;
  int D.41137;
  struct MonoClass * D.41140;
  struct MonoInst * * sp.329;
  struct MonoDebugOptions * D.41151;
  int D.41152;
  struct MonoDebugOptions * D.41160;
  int D.41161;
  struct MonoDebugOptions * D.41169;
  int D.41170;
  unsigned char D.41174;
  unsigned char D.41175;
  unsigned int D.41176;
  int D.41177;
  struct MonoType * D.41180;
  int D.41181;
  struct MonoInst * iftmp.330;
  int D.41187;
  unsigned int D.41188;
  sizetype D.41191;
  sizetype D.41192;
  sizetype D.41193;
  struct MonoInst * * D.41194;
  struct MonoInst * iftmp.331;
  int D.41197;
  unsigned int D.41198;
  sizetype D.41201;
  sizetype D.41202;
  struct MonoInst * * D.41203;
  _Bool D.41205;
  long int D.41206;
  long int D.41207;
  _Bool D.41210;
  long int D.41211;
  long int D.41212;
  unsigned char D.41215;
  unsigned char D.41216;
  unsigned char D.41217;
  unsigned char D.41218;
  struct MonoInst * * sp.332;
  struct MonoDebugOptions * D.41229;
  int D.41230;
  struct MonoDebugOptions * D.41238;
  int D.41239;
  struct MonoDebugOptions * D.41247;
  int D.41248;
  int D.41252;
  struct MonoDebugOptions * D.41259;
  int D.41260;
  struct MonoDebugOptions * D.41268;
  int D.41269;
  struct MonoDebugOptions * D.41277;
  int D.41278;
  unsigned int D.41281;
  int D.41282;
  unsigned char D.41288;
  struct MonoInst * * sp.333;
  struct MonoDebugOptions * D.41296;
  int D.41297;
  struct MonoDebugOptions * D.41306;
  int D.41307;
  long unsigned int D.41312;
  long unsigned int D.41313;
  unsigned int D.41316;
  unsigned int D.41317;
  unsigned int D.41320;
  long int D.41321;
  unsigned int D.41324;
  long int D.41325;
  unsigned int D.41329;
  _Bool D.41330;
  long int D.41331;
  long int D.41332;
  unsigned int D.41335;
  long int D.41336;
  struct MonoDebugOptions * D.41343;
  int D.41344;
  unsigned char * D.41346;
  struct MonoDebugOptions * D.41353;
  int D.41354;
  unsigned int D.41356;
  struct MonoDebugOptions * D.41363;
  int D.41364;
  struct MonoDebugOptions * D.41372;
  int D.41373;
  struct MonoClass * klass.334;
  struct MonoDebugOptions * D.41379;
  int D.41380;
  int D.41382;
  long int D.41385;
  struct MonoInst * D.41386;
  int D.41387;
  int D.41388;
  struct MonoDebugOptions * D.41399;
  int D.41400;
  struct MonoDebugOptions * D.41405;
  int D.41406;
  struct MonoDebugOptions * D.41414;
  int D.41415;
  struct MonoInst * * D.41421;
  struct MonoInst * D.41422;
  short unsigned int D.41423;
  long int D.41425;
  int D.41427;
  int D.41436;
  struct MonoInst * D.41437;
  struct MonoDebugOptions * D.41447;
  int D.41448;
  unsigned char D.41450;
  int D.41451;
  int D.41452;
  int D.41455;
  unsigned int D.41458;
  long int D.41459;
  unsigned int D.41462;
  unsigned int D.41463;
  long int D.41464;
  unsigned int D.41467;
  unsigned int D.41468;
  unsigned int D.41471;
  unsigned int D.41472;
  _Bool D.41473;
  long int D.41474;
  long int D.41475;
  long int D.41478;
  struct MonoInst * D.41479;
  int D.41480;
  int D.41481;
  struct MonoInst * D.41482;
  long int D.41483;
  long unsigned int D.41484;
  long unsigned int D.41485;
  struct MonoInst * * D.41486;
  struct MonoInst * D.41487;
  struct MonoType * D.41488;
  unsigned int D.41489;
  short unsigned int D.41490;
  struct MonoInst * D.41491;
  long int D.41492;
  long unsigned int D.41493;
  long unsigned int D.41494;
  struct MonoInst * * D.41495;
  struct MonoInst * D.41496;
  struct MonoType * D.41497;
  struct MonoInst * D.41498;
  long int D.41499;
  long unsigned int D.41500;
  long unsigned int D.41501;
  struct MonoInst * * D.41502;
  struct MonoInst * D.41503;
  struct MonoClass * D.41504;
  struct MonoInst * D.41505;
  long int D.41506;
  long unsigned int D.41507;
  long unsigned int D.41508;
  struct MonoInst * * D.41509;
  struct MonoInst * D.41510;
  int D.41511;
  unsigned char D.41512;
  <unnamed type> D.41513;
  unsigned int D.41514;
  int D.41515;
  short unsigned int D.41516;
  struct MonoInst * D.41519;
  long int D.41520;
  long unsigned int D.41521;
  long unsigned int D.41522;
  struct MonoInst * * D.41523;
  struct MonoInst * D.41524;
  struct MonoType * D.41525;
  struct MonoClass * D.41526;
  int D.41530;
  const char * D.41539;
  gchar * D.41540;
  struct MonoDebugOptions * D.41549;
  int D.41550;
  struct MonoDebugOptions * D.41558;
  int D.41559;
  unsigned int D.41563;
  long unsigned int D.41565;
  long unsigned int D.41566;
  int D.41569;
  unsigned char D.41573;
  struct MonoDebugOptions * D.41574;
  int D.41575;
  struct MonoType * D.41577;
  int D.41578;
  long int D.41579;
  unsigned int D.41580;
  int D.41581;
  struct MonoInst * * sp.335;
  const char * D.41588;
  gchar * D.41589;
  struct MonoDebugOptions * D.41598;
  int D.41599;
  struct MonoInst * iftmp.336;
  long int D.41607;
  struct MonoInst * D.41608;
  int D.41609;
  int D.41610;
  unsigned char D.41611;
  unsigned char D.41612;
  struct MonoClass * D.41613;
  unsigned int D.41614;
  int D.41615;
  struct MonoType * D.41618;
  int D.41619;
  struct MonoInst * iftmp.337;
  int D.41625;
  int D.41626;
  unsigned int D.41627;
  sizetype D.41630;
  sizetype D.41631;
  sizetype D.41632;
  struct MonoInst * * D.41633;
  struct MonoInst * iftmp.338;
  int D.41636;
  unsigned int D.41637;
  sizetype D.41640;
  sizetype D.41641;
  struct MonoInst * * D.41642;
  _Bool D.41644;
  long int D.41645;
  long int D.41646;
  _Bool D.41649;
  long int D.41650;
  long int D.41651;
  unsigned char D.41654;
  unsigned char D.41655;
  unsigned char D.41656;
  unsigned char D.41657;
  struct MonoType * D.41661;
  unsigned int D.41662;
  short unsigned int D.41663;
  int D.41664;
  unsigned int D.41665;
  int D.41666;
  struct MonoInst * * sp.339;
  struct MonoDebugOptions * D.41675;
  int D.41676;
  struct MonoDebugOptions * D.41682;
  int D.41683;
  struct MonoDebugOptions * D.41689;
  int D.41690;
  struct MonoDebugOptions * D.41696;
  int D.41697;
  struct MonoDebugOptions * D.41705;
  int D.41706;
  struct MonoBasicBlock * D.41708;
  struct MonoBasicBlock * D.41711;
  struct MonoInst * D.41715;
  long int D.41724;
  struct MonoInst * D.41725;
  int D.41726;
  int D.41727;
  long int D.41728;
  long unsigned int D.41729;
  long unsigned int D.41730;
  struct MonoInst * * D.41731;
  struct MonoInst * D.41732;
  struct MonoType * D.41733;
  unsigned int D.41734;
  short unsigned int D.41735;
  struct MonoClass * D.41736;
  int D.41737;
  int D.41738;
  short unsigned int D.41739;
  struct MonoClass * D.41742;
  struct MonoInst * D.41750;
  struct MonoType * D.41755;
  long unsigned int D.41756;
  struct MonoInst * * D.41761;
  long unsigned int D.41762;
  long unsigned int D.41763;
  long int D.41766;
  struct MonoInst * D.41767;
  int D.41768;
  int D.41769;
  int D.41770;
  unsigned int D.41774;
  struct MonoInst * D.41781;
  short int D.41784;
  short unsigned int D.41787;
  unsigned char D.41790;
  unsigned char D.41791;
  struct MonoInst * D.41794;
  struct MonoBasicBlock * D.41798;
  struct MonoInst * D.41799;
  long unsigned int D.41805;
  long unsigned int D.41806;
  int D.41807;
  long unsigned int D.41808;
  long unsigned int D.41809;
  long unsigned int D.41812;
  long unsigned int D.41813;
  long unsigned int D.41814;
  long int D.41817;
  struct MonoInst * D.41818;
  int D.41819;
  int D.41820;
  long int D.41821;
  unsigned int i.340;
  unsigned int D.41825;
  int D.41826;
  int D.41827;
  unsigned int D.41828;
  struct GHashTable * D.41829;
  unsigned int D.41832;
  int D.41833;
  int D.41836;
  gchar * D.41839;
  struct GSList * D.41840;
  struct GSList * D.41841;
  int D.41842;
  struct GSList * D.41847;
  _Bool D.41848;
  long int D.41849;
  long int D.41850;
  struct GSList * D.41853;
  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.30878 = method->klass;
      D.30879 = D.30878->image;
      D.30880 = D.30879->assembly;
      D.30881 = D.30880->corlib_internal;
      D.30882 = D.30881 != 0;
      dont_verify = (gboolean) D.30882;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30885 = D.30884 == 40;
      D.30886 = (int) D.30885;
      dont_verify = D.30886 | dont_verify;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30887 = D.30884 == 44;
      D.30888 = (int) D.30887;
      dont_verify = D.30888 | dont_verify;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30889 = D.30884 == 24;
      D.30890 = (int) D.30889;
      dont_verify = D.30890 | dont_verify;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30891 = D.30884 == 108;
      D.30892 = (int) D.30891;
      dont_verify = D.30892 | dont_verify;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30893 = D.30884 == 104;
      D.30894 = (int) D.30893;
      dont_verify = D.30894 | dont_verify;
      D.30895 = mono_security_get_mode ();
      D.30896 = D.30895 == 3;
      D.30897 = (int) D.30896;
      dont_verify = D.30897 | dont_verify;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30889 = D.30884 == 24;
      dont_verify_stloc = (gboolean) D.30889;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30898 = D.30884 == 100;
      D.30899 = (int) D.30898;
      dont_verify_stloc = D.30899 | dont_verify_stloc;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30900 = D.30884 == 20;
      D.30901 = (int) D.30900;
      dont_verify_stloc = D.30901 | dont_verify_stloc;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.30902 = D.30884 == 84;
      D.30903 = (int) D.30902;
      dont_verify_stloc = D.30903 | dont_verify_stloc;
      D.30878 = method->klass;
      image = D.30878->image;
      header = mono_method_get_header (method);
      if (header == 0B) goto <D.30904>; else goto <D.30905>;
      <D.30904>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.30906>; else goto <D.30907>;
        <D.30906>:
        D.30908 = error->exception_type;
        D.30909 = (int) D.30908;
        mono_cfg_set_exception (cfg, D.30909);
        goto <D.30910>;
        <D.30907>:
        mono_cfg_set_exception (cfg, 3);
        D.30911 = cfg->method;
        D.30912 = D.30911->name;
        D.30913 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.30912);
        cfg->exception_message = D.30913;
        <D.30910>:
        goto exception_exit;
      }
      <D.30905>:
      generic_container = mono_method_get_generic_container (method);
      sig = mono_method_signature (method);
      D.30914 = sig->hasthis;
      D.30915 = (int) D.30914;
      D.30916 = sig->param_count;
      D.30917 = (int) D.30916;
      D.30918 = D.30915 + D.30917;
      num_args = (guint) D.30918;
      ip = header->code;
      cfg->cil_start = ip;
      D.30919 = header->code_size;
      D.30920 = (sizetype) D.30919;
      end = ip + D.30920;
      D.30921 = cfg->stat_cil_code_size;
      D.30922 = (unsigned int) D.30921;
      D.30919 = header->code_size;
      D.30923 = D.30922 + D.30919;
      D.30924 = (int) D.30923;
      cfg->stat_cil_code_size = D.30924;
      D.30925 = header->init_locals;
      init_locals = (gboolean) D.30925;
      D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.30930 = D.30929 & 32;
      if (D.30930 != 0) goto <D.30931>; else goto <D.30927>;
      <D.30931>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.30932>; else goto <D.30927>;
      <D.30932>:
      iftmp.64 = 1;
      goto <D.30928>;
      <D.30927>:
      iftmp.64 = 0;
      <D.30928>:
      seq_points = iftmp.64;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 20) goto <D.30933>; else goto <D.30934>;
      <D.30933>:
      seq_points = 0;
      <D.30934>:
      D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.30930 = D.30929 & 32;
      if (D.30930 != 0) goto <D.30935>; else goto <D.30936>;
      <D.30935>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.30937>; else goto <D.30938>;
      <D.30937>:
      minfo = mono_debug_lookup_method (method);
      if (minfo != 0B) goto <D.30939>; else goto <D.30940>;
      <D.30939>:
      {
        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.30941 = cfg->mempool;
            D.30919 = header->code_size;
            D.30942 = mono_bitset_alloc_size (D.30919, 0);
            D.30943 = mono_mempool_alloc0 (D.30941, D.30942);
            D.30919 = header->code_size;
            seq_point_locs = mono_bitset_mem_new (D.30943, D.30919, 0);
            D.30941 = cfg->mempool;
            D.30919 = header->code_size;
            D.30944 = mono_bitset_alloc_size (D.30919, 0);
            D.30945 = mono_mempool_alloc0 (D.30941, D.30944);
            D.30919 = header->code_size;
            seq_point_set_locs = mono_bitset_mem_new (D.30945, D.30919, 0);
            sym_seq_points = 1;
            i = 0;
            goto <D.27800>;
            <D.27799>:
            il_offsets.65 = il_offsets;
            D.30947 = (long unsigned int) i;
            D.30948 = D.30947 * 4;
            D.30949 = il_offsets.65 + D.30948;
            D.30950 = *D.30949;
            D.30951 = (unsigned int) D.30950;
            D.30919 = header->code_size;
            if (D.30951 < D.30919) goto <D.30952>; else goto <D.30953>;
            <D.30952>:
            il_offsets.65 = il_offsets;
            D.30947 = (long unsigned int) i;
            D.30948 = D.30947 * 4;
            D.30949 = il_offsets.65 + D.30948;
            D.30950 = *D.30949;
            D.30954 = (long unsigned int) D.30950;
            D.30955 = D.30954 / 64;
            D.30956 = seq_point_locs->data[D.30955];
            il_offsets.65 = il_offsets;
            D.30947 = (long unsigned int) i;
            D.30948 = D.30947 * 4;
            D.30949 = il_offsets.65 + D.30948;
            D.30950 = *D.30949;
            D.30957 = D.30950 & 63;
            D.30958 = 1 << D.30957;
            D.30959 = D.30956 | D.30958;
            seq_point_locs->data[D.30955] = D.30959;
            <D.30953>:
            i = i + 1;
            <D.27800>:
            n_il_offsets.66 = n_il_offsets;
            if (i < n_il_offsets.66) goto <D.27799>; else goto <D.27801>;
            <D.27801>:
            il_offsets.65 = il_offsets;
            monoeg_g_free (il_offsets.65);
            line_numbers.67 = line_numbers;
            monoeg_g_free (line_numbers.67);
          }
        finally
          {
            n_il_offsets = {CLOBBER};
            il_offsets = {CLOBBER};
            line_numbers = {CLOBBER};
          }
      }
      <D.30940>:
      <D.30938>:
      <D.30936>:
      init_locals = 1;
      method_definition = method;
      goto <D.27804>;
      <D.27803>:
      {
        struct MonoMethodInflated * imethod;

        imethod = method_definition;
        method_definition = imethod->declaring;
      }
      <D.27804>:
      D.30962 = BIT_FIELD_REF <*method_definition, 64, 256>;
      D.30963 = D.30962 & 4096;
      if (D.30963 != 0) goto <D.27803>; else goto <D.27805>;
      <D.27805>:
      if (dont_verify == 0) goto <D.30964>; else goto <D.30965>;
      <D.30964>:
      D.30966 = cfg->domain;
      D.30967 = mini_assembly_can_skip_verification (D.30966, method);
      if (D.30967 != 0) goto <D.30968>; else goto <D.30969>;
      <D.30968>:
      dont_verify = 1;
      dont_verify_stloc = 1;
      <D.30969>:
      <D.30965>:
      D.30970 = BIT_FIELD_REF <*sig, 64, 64>;
      D.30971 = D.30970 & 144115188075855872;
      if (D.30971 != 0) goto <D.30972>; else goto <D.30973>;
      <D.30972>:
      generic_context = mono_method_get_context (method);
      goto <D.30974>;
      <D.30973>:
      if (generic_container != 0B) goto <D.30975>; else goto <D.30976>;
      <D.30975>:
      generic_context = &generic_container->context;
      <D.30976>:
      <D.30974>:
      cfg->generic_context = generic_context;
      D.30977 = cfg->generic_sharing_context;
      if (D.30977 == 0B) goto <D.30978>; else goto <D.30979>;
      <D.30978>:
      D.30970 = BIT_FIELD_REF <*sig, 64, 64>;
      D.30980 = D.30970 & 288230376151711744;
      D.30981 = D.30980 != 0;
      D.30982 = (long int) D.30981;
      D.30983 = __builtin_expect (D.30982, 0);
      if (D.30983 != 0) goto <D.30984>; else goto <D.30985>;
      <D.30984>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6727, "!sig->has_type_parameters");
      <D.30985>:
      <D.30979>:
      D.30986 = sig->generic_param_count;
      if (D.30986 != 0) goto <D.30987>; else goto <D.30988>;
      <D.30987>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 0) goto <D.30989>; else goto <D.30990>;
      <D.30989>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30991 = D.30883 & 4096;
      D.30992 = D.30991 == 0;
      D.30993 = (long int) D.30992;
      D.30994 = __builtin_expect (D.30993, 0);
      if (D.30994 != 0) goto <D.30995>; else goto <D.30996>;
      <D.30995>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6730, "method->is_inflated");
      <D.30996>:
      D.30997 = mono_method_get_context (method);
      D.30998 = D.30997->method_inst;
      D.30999 = D.30998 == 0B;
      D.31000 = (long int) D.30999;
      D.31001 = __builtin_expect (D.31000, 0);
      if (D.31001 != 0) goto <D.31002>; else goto <D.31003>;
      <D.31002>:
      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.31003>:
      <D.30990>:
      <D.30988>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30991 = D.30883 & 4096;
      if (D.30991 != 0) goto <D.31004>; else goto <D.31005>;
      <D.31004>:
      D.31006 = mono_method_get_context (method);
      D.31007 = D.31006->method_inst;
      if (D.31007 != 0B) goto <D.31008>; else goto <D.31009>;
      <D.31008>:
      D.30986 = sig->generic_param_count;
      D.31010 = D.30986 == 0;
      D.31011 = (long int) D.31010;
      D.31012 = __builtin_expect (D.31011, 0);
      if (D.31012 != 0) goto <D.31013>; else goto <D.31014>;
      <D.31013>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6734, "sig->generic_param_count");
      <D.31014>:
      <D.31009>:
      <D.31005>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31015>; else goto <D.31016>;
      <D.31015>:
      cfg->real_offset = 0;
      goto <D.31017>;
      <D.31016>:
      cfg->real_offset = inline_offset;
      <D.31017>:
      D.30941 = cfg->mempool;
      D.30919 = header->code_size;
      D.31018 = D.30919 * 8;
      D.31019 = mono_mempool_alloc0 (D.30941, D.31018);
      cfg->cil_offset_to_bb = D.31019;
      D.30919 = header->code_size;
      D.31020 = (int) D.30919;
      cfg->cil_offset_to_bb_len = D.31020;
      cfg->current_method = method;
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31022>; else goto <D.31023>;
      <D.31022>:
      D.31024 = mono_method_full_name (method, 1);
      printf ("method to IR %s\n", D.31024);
      <D.31023>:
      D.30941 = cfg->mempool;
      D.31025 = num_args * 8;
      param_types = mono_mempool_alloc (D.30941, D.31025);
      D.30970 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31026 = D.30970 & 18014398509481984;
      if (D.31026 != 0) goto <D.31027>; else goto <D.31028>;
      <D.31027>:
      D.30878 = method->klass;
      D.31030 = BIT_FIELD_REF <*D.30878, 64, 256>;
      D.31031 = D.31030 & 8;
      if (D.31031 != 0) goto <D.31032>; else goto <D.31033>;
      <D.31032>:
      D.30878 = method->klass;
      iftmp.68 = &D.30878->this_arg;
      goto <D.31034>;
      <D.31033>:
      D.30878 = method->klass;
      iftmp.68 = &D.30878->byval_arg;
      <D.31034>:
      *param_types = iftmp.68;
      <D.31028>:
      n = 0;
      goto <D.27807>;
      <D.27806>:
      D.30914 = sig->hasthis;
      D.30915 = (int) D.30914;
      D.31035 = D.30915 + n;
      D.31036 = (long unsigned int) D.31035;
      D.31037 = D.31036 * 8;
      D.31038 = param_types + D.31037;
      D.31039 = sig->params[n];
      *D.31038 = D.31039;
      n = n + 1;
      <D.27807>:
      D.30916 = sig->param_count;
      D.30917 = (int) D.30916;
      if (D.30917 > n) goto <D.27806>; else goto <D.27808>;
      <D.27808>:
      cfg->arg_types = param_types;
      dont_inline = monoeg_g_list_prepend (dont_inline, method);
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31040>; else goto <D.31041>;
      <D.31040>:
      D.31042 = cfg->prof_options;
      D.31043 = D.31042 & 16384;
      if (D.31043 != 0) goto <D.31044>; else goto <D.31045>;
      <D.31044>:
      D.30911 = cfg->method;
      D.30919 = header->code_size;
      D.31046 = (int) D.30919;
      D.31047 = mono_profiler_coverage_alloc (D.30911, D.31046);
      cfg->coverage_info = D.31047;
      <D.31045>:
      D.30941 = cfg->mempool;
      start_bblock = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.31049 = D.31048;
      D.31050 = D.31049 + 1;
      cfg->num_bblocks = D.31050;
      D.31051 = (int) D.31049;
      start_bblock->block_num = D.31051;
      cfg->bb_entry = start_bblock;
      start_bblock->cil_code = 0B;
      start_bblock->cil_length = 0;
      D.30941 = cfg->mempool;
      end_bblock = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.31052 = D.31048;
      D.31053 = D.31052 + 1;
      cfg->num_bblocks = D.31053;
      D.31054 = (int) D.31052;
      end_bblock->block_num = D.31054;
      cfg->bb_exit = end_bblock;
      end_bblock->cil_code = 0B;
      end_bblock->cil_length = 0;
      D.31055 = end_bblock->flags;
      D.31056 = D.31055 | 32;
      end_bblock->flags = D.31056;
      D.31048 = cfg->num_bblocks;
      D.31057 = D.31048 != 2;
      D.31058 = (long int) D.31057;
      D.31059 = __builtin_expect (D.31058, 0);
      if (D.31059 != 0) goto <D.31060>; else goto <D.31061>;
      <D.31060>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6780, "cfg->num_bblocks == 2");
      <D.31061>:
      arg_array = cfg->args;
      D.31062 = BIT_FIELD_REF <*header, 64, 64>;
      D.31063 = D.31062 & 9223090561878065152;
      if (D.31063 != 0) goto <D.31064>; else goto <D.31065>;
      <D.31064>:
      D.31066 = monoeg_g_hash_table_new (0B, 0B);
      cfg->spvars = D.31066;
      D.31067 = monoeg_g_hash_table_new (0B, 0B);
      cfg->exvars = D.31067;
      <D.31065>:
      i = 0;
      goto <D.27815>;
      <D.27814>:
      {
        struct MonoBasicBlock * try_bb;
        struct MonoExceptionClause * clause;

        D.31068 = header->clauses;
        D.31069 = (long unsigned int) i;
        D.31070 = D.31069 * 32;
        clause = D.31068 + D.31070;
        D.31071 = cfg->cil_offset_to_bb;
        D.31072 = clause->try_offset;
        D.31073 = (sizetype) D.31072;
        D.31074 = ip + D.31073;
        D.31075 = (long int) D.31074;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31078 = D.31075 - D.31077;
        D.31079 = (long unsigned int) D.31078;
        D.31080 = D.31079 * 8;
        D.31081 = D.31071 + D.31080;
        try_bb = *D.31081;
        if (try_bb == 0B) goto <D.31082>; else goto <D.31083>;
        <D.31082>:
        D.31072 = clause->try_offset;
        D.31073 = (sizetype) D.31072;
        D.31074 = ip + D.31073;
        if (D.31074 >= end) goto <D.31084>; else goto <D.31086>;
        <D.31086>:
        D.31072 = clause->try_offset;
        D.31073 = (sizetype) D.31072;
        D.31087 = ip + D.31073;
        D.31088 = header->code;
        if (D.31087 < D.31088) goto <D.31084>; else goto <D.31085>;
        <D.31084>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.31090>; else goto <D.31091>;
        <D.31090>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.31092>; else goto <D.31093>;
        <D.31092>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31093>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31091>:
        D.31094 = mini_get_debug_options ();
        D.31095 = D.31094->break_on_unverified;
        if (D.31095 != 0) goto <D.31096>; else goto unverified;
        <D.31096>:
        raise (5);
        <D.31085>:
        D.30941 = cfg->mempool;
        try_bb = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.31097 = D.31048;
        D.31098 = D.31097 + 1;
        cfg->num_bblocks = D.31098;
        D.31099 = (int) D.31097;
        try_bb->block_num = D.31099;
        D.31072 = clause->try_offset;
        D.31073 = (sizetype) D.31072;
        D.31074 = ip + D.31073;
        try_bb->cil_code = D.31074;
        D.31100 = try_bb->cil_code;
        if (D.31100 != 0B) goto <D.31101>; else goto <D.31102>;
        <D.31101>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31100 = try_bb->cil_code;
        D.31103 = (long int) D.31100;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31104 = D.31103 - D.31077;
        D.31105 = (long unsigned int) D.31104;
        D.31106 = D.31105 * 8;
        D.31107 = D.31071 + D.31106;
        *D.31107 = try_bb;
        <D.31102>:
        D.31108 = cfg->real_offset;
        try_bb->real_offset = D.31108;
        <D.31083>:
        D.31072 = clause->try_offset;
        try_bb->real_offset = D.31072;
        try_bb->try_start = 1;
        D.31109 = i + 1;
        D.31110 = D.31109 << 8;
        D.31111 = (unsigned int) D.31110;
        D.31112 = clause->flags;
        D.31113 = D.31111 | D.31112;
        try_bb->region = D.31113;
        D.31071 = cfg->cil_offset_to_bb;
        D.31114 = clause->handler_offset;
        D.31115 = (sizetype) D.31114;
        D.31116 = ip + D.31115;
        D.31117 = (long int) D.31116;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31118 = D.31117 - D.31077;
        D.31119 = (long unsigned int) D.31118;
        D.31120 = D.31119 * 8;
        D.31121 = D.31071 + D.31120;
        tblock = *D.31121;
        if (tblock == 0B) goto <D.31122>; else goto <D.31123>;
        <D.31122>:
        D.31114 = clause->handler_offset;
        D.31115 = (sizetype) D.31114;
        D.31116 = ip + D.31115;
        if (D.31116 >= end) goto <D.31124>; else goto <D.31126>;
        <D.31126>:
        D.31114 = clause->handler_offset;
        D.31115 = (sizetype) D.31114;
        D.31127 = ip + D.31115;
        D.31088 = header->code;
        if (D.31127 < D.31088) goto <D.31124>; else goto <D.31125>;
        <D.31124>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.31128>; else goto <D.31129>;
        <D.31128>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.31130>; else goto <D.31131>;
        <D.31130>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31131>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31129>:
        D.31132 = mini_get_debug_options ();
        D.31133 = D.31132->break_on_unverified;
        if (D.31133 != 0) goto <D.31134>; else goto unverified;
        <D.31134>:
        raise (5);
        <D.31125>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.31135 = D.31048;
        D.31136 = D.31135 + 1;
        cfg->num_bblocks = D.31136;
        D.31137 = (int) D.31135;
        tblock->block_num = D.31137;
        D.31114 = clause->handler_offset;
        D.31115 = (sizetype) D.31114;
        D.31116 = ip + D.31115;
        tblock->cil_code = D.31116;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.31139>; else goto <D.31140>;
        <D.31139>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.31140>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.31123>:
        D.31114 = clause->handler_offset;
        tblock->real_offset = D.31114;
        D.31146 = tblock->flags;
        D.31147 = D.31146 | 16;
        tblock->flags = D.31147;
        if (0 != 0) goto <D.31148>; else goto <D.31149>;
        <D.31148>:
        link_bblock (cfg, try_bb, tblock);
        <D.31149>:
        D.31114 = clause->handler_offset;
        D.31115 = (sizetype) D.31114;
        D.31116 = ip + D.31115;
        D.31150 = *D.31116;
        if (D.31150 == 38) goto <D.31151>; else goto <D.31152>;
        <D.31151>:
        D.31146 = tblock->flags;
        D.31153 = D.31146 | 4;
        tblock->flags = D.31153;
        <D.31152>:
        D.31112 = clause->flags;
        D.31156 = D.31112 + 4294967295;
        if (D.31156 <= 1) goto <D.31154>; else goto <D.31157>;
        <D.31157>:
        D.31112 = clause->flags;
        if (D.31112 == 4) goto <D.31154>; else goto <D.31155>;
        <D.31154>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 736;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31163 = tblock->last_ins;
        if (D.31163 != 0B) goto <D.31164>; else goto <D.31165>;
        <D.31164>:
        D.31163 = tblock->last_ins;
        D.31163->next = ins;
        D.31163 = tblock->last_ins;
        ins->prev = D.31163;
        tblock->last_ins = ins;
        goto <D.31166>;
        <D.31165>:
        tblock->last_ins = ins;
        D.31163 = tblock->last_ins;
        tblock->code = D.31163;
        <D.31166>:
        if (seq_points != 0) goto <D.31167>; else goto <D.31168>;
        <D.31167>:
        D.31112 = clause->flags;
        if (D.31112 != 2) goto <D.31169>; else goto <D.31170>;
        <D.31169>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31114 = clause->handler_offset;
        D.31171 = (long int) D.31114;
        ins->data.op[1].const_val = D.31171;
        ins->flags = 1;
        D.31163 = tblock->last_ins;
        if (D.31163 != 0B) goto <D.31172>; else goto <D.31173>;
        <D.31172>:
        D.31163 = tblock->last_ins;
        D.31163->next = ins;
        D.31163 = tblock->last_ins;
        ins->prev = D.31163;
        tblock->last_ins = ins;
        goto <D.31174>;
        <D.31173>:
        tblock->last_ins = ins;
        D.31163 = tblock->last_ins;
        tblock->code = D.31163;
        <D.31174>:
        <D.31170>:
        <D.31168>:
        D.31112 = clause->flags;
        if (D.31112 == 4) goto <D.31175>; else goto <D.31176>;
        <D.31175>:
        D.31146 = tblock->flags;
        D.31177 = D.31146 | 8;
        tblock->flags = D.31177;
        <D.31176>:
        <D.31155>:
        D.31112 = clause->flags;
        if (D.31112 <= 1) goto <D.31178>; else goto <D.31179>;
        <D.31178>:
        {
          struct MonoInst * dummy_use;

          tblock->in_scount = 1;
          D.30941 = cfg->mempool;
          D.31180 = mono_mempool_alloc (D.30941, 8);
          tblock->in_stack = D.31180;
          D.31181 = tblock->in_stack;
          D.31114 = clause->handler_offset;
          D.31182 = (int) D.31114;
          D.31183 = mono_create_exvar_for_offset (cfg, D.31182);
          *D.31181 = D.31183;
          cfg->cbb = tblock;
          D.30941 = cfg->mempool;
          dummy_use = mono_mempool_alloc (D.30941, 80);
          dummy_use->data.op[1].const_val = 0;
          D.31184 = dummy_use->data.op[1].const_val;
          dummy_use->data.op[0].const_val = D.31184;
          dummy_use->prev = 0B;
          D.31185 = dummy_use->prev;
          dummy_use->next = D.31185;
          dummy_use->opcode = 796;
          dummy_use->flags = 0;
          dummy_use->type = 0;
          dummy_use->dreg = -1;
          dummy_use->sreg3 = -1;
          D.31186 = dummy_use->sreg3;
          dummy_use->sreg2 = D.31186;
          D.31187 = dummy_use->sreg2;
          dummy_use->sreg1 = D.31187;
          D.31162 = cfg->ip;
          dummy_use->cil_code = D.31162;
          D.31181 = tblock->in_stack;
          D.31188 = *D.31181;
          D.31189 = D.31188->dreg;
          dummy_use->sreg1 = D.31189;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31192>; else goto <D.31193>;
          <D.31192>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = dummy_use;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          dummy_use->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = dummy_use;
          goto <D.31194>;
          <D.31193>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = dummy_use;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31194>:
          D.31112 = clause->flags;
          if (D.31112 == 1) goto <D.31195>; else goto <D.31196>;
          <D.31195>:
          D.31071 = cfg->cil_offset_to_bb;
          D.31197 = clause->data.filter_offset;
          D.31198 = (sizetype) D.31197;
          D.31199 = ip + D.31198;
          D.31200 = (long int) D.31199;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.31201 = D.31200 - D.31077;
          D.31202 = (long unsigned int) D.31201;
          D.31203 = D.31202 * 8;
          D.31204 = D.31071 + D.31203;
          tblock = *D.31204;
          if (tblock == 0B) goto <D.31205>; else goto <D.31206>;
          <D.31205>:
          D.31197 = clause->data.filter_offset;
          D.31198 = (sizetype) D.31197;
          D.31199 = ip + D.31198;
          if (D.31199 >= end) goto <D.31207>; else goto <D.31209>;
          <D.31209>:
          D.31197 = clause->data.filter_offset;
          D.31198 = (sizetype) D.31197;
          D.31210 = ip + D.31198;
          D.31088 = header->code;
          if (D.31210 < D.31088) goto <D.31207>; else goto <D.31208>;
          <D.31207>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.31211>; else goto <D.31212>;
          <D.31211>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.31213>; else goto <D.31214>;
          <D.31213>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.31214>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.31212>:
          D.31215 = mini_get_debug_options ();
          D.31216 = D.31215->break_on_unverified;
          if (D.31216 != 0) goto <D.31217>; else goto unverified;
          <D.31217>:
          raise (5);
          <D.31208>:
          D.30941 = cfg->mempool;
          tblock = mono_mempool_alloc0 (D.30941, 296);
          D.31048 = cfg->num_bblocks;
          D.31218 = D.31048;
          D.31219 = D.31218 + 1;
          cfg->num_bblocks = D.31219;
          D.31220 = (int) D.31218;
          tblock->block_num = D.31220;
          D.31197 = clause->data.filter_offset;
          D.31198 = (sizetype) D.31197;
          D.31199 = ip + D.31198;
          tblock->cil_code = D.31199;
          D.31138 = tblock->cil_code;
          if (D.31138 != 0B) goto <D.31221>; else goto <D.31222>;
          <D.31221>:
          D.31071 = cfg->cil_offset_to_bb;
          D.31138 = tblock->cil_code;
          D.31141 = (long int) D.31138;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.31142 = D.31141 - D.31077;
          D.31143 = (long unsigned int) D.31142;
          D.31144 = D.31143 * 8;
          D.31145 = D.31071 + D.31144;
          *D.31145 = tblock;
          <D.31222>:
          D.31108 = cfg->real_offset;
          tblock->real_offset = D.31108;
          <D.31206>:
          D.31146 = tblock->flags;
          D.31147 = D.31146 | 16;
          tblock->flags = D.31147;
          D.31197 = clause->data.filter_offset;
          tblock->real_offset = D.31197;
          tblock->in_scount = 1;
          D.30941 = cfg->mempool;
          D.31223 = mono_mempool_alloc (D.30941, 8);
          tblock->in_stack = D.31223;
          D.31181 = tblock->in_stack;
          D.31114 = clause->handler_offset;
          D.31182 = (int) D.31114;
          D.31224 = mono_create_exvar_for_offset (cfg, D.31182);
          *D.31181 = D.31224;
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 736;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          D.31163 = tblock->last_ins;
          if (D.31163 != 0B) goto <D.31225>; else goto <D.31226>;
          <D.31225>:
          D.31163 = tblock->last_ins;
          D.31163->next = ins;
          D.31163 = tblock->last_ins;
          ins->prev = D.31163;
          tblock->last_ins = ins;
          goto <D.31227>;
          <D.31226>:
          tblock->last_ins = ins;
          D.31163 = tblock->last_ins;
          tblock->code = D.31163;
          <D.31227>:
          <D.31196>:
        }
        <D.31179>:
        D.31112 = clause->flags;
        if (D.31112 != 1) goto <D.31228>; else goto <D.31229>;
        <D.31228>:
        D.31230 = clause->data.catch_class;
        if (D.31230 != 0B) goto <D.31231>; else goto <D.31232>;
        <D.31231>:
        D.30977 = cfg->generic_sharing_context;
        if (D.30977 != 0B) goto <D.31233>; else goto <D.31234>;
        <D.31233>:
        D.31230 = clause->data.catch_class;
        D.31235 = mono_class_check_context_used (D.31230);
        if (D.31235 != 0) goto <D.31236>; else goto <D.31237>;
        <D.31236>:
        D.31241 = method->flags;
        D.31242 = (int) D.31241;
        D.31243 = D.31242 & 16;
        if (D.31243 != 0) goto <D.31238>; else goto <D.31244>;
        <D.31244>:
        D.31245 = mini_method_get_context (method);
        D.31246 = D.31245->method_inst;
        if (D.31246 != 0B) goto <D.31238>; else goto <D.31247>;
        <D.31247>:
        D.30878 = method->klass;
        D.31030 = BIT_FIELD_REF <*D.30878, 64, 256>;
        D.31031 = D.31030 & 8;
        if (D.31031 != 0) goto <D.31238>; else goto <D.31239>;
        <D.31238>:
        mono_get_vtable_var (cfg);
        goto <D.31240>;
        <D.31239>:
        {
          struct MonoInst * dummy_use;

          D.30941 = cfg->mempool;
          dummy_use = mono_mempool_alloc (D.30941, 80);
          dummy_use->data.op[1].const_val = 0;
          D.31248 = dummy_use->data.op[1].const_val;
          dummy_use->data.op[0].const_val = D.31248;
          dummy_use->prev = 0B;
          D.31249 = dummy_use->prev;
          dummy_use->next = D.31249;
          dummy_use->opcode = 796;
          dummy_use->flags = 0;
          dummy_use->type = 0;
          dummy_use->dreg = -1;
          dummy_use->sreg3 = -1;
          D.31250 = dummy_use->sreg3;
          dummy_use->sreg2 = D.31250;
          D.31251 = dummy_use->sreg2;
          dummy_use->sreg1 = D.31251;
          D.31162 = cfg->ip;
          dummy_use->cil_code = D.31162;
          D.31252 = *arg_array;
          D.31253 = D.31252->dreg;
          dummy_use->sreg1 = D.31253;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31254>; else goto <D.31255>;
          <D.31254>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = dummy_use;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          dummy_use->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = dummy_use;
          goto <D.31256>;
          <D.31255>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = dummy_use;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31256>:
        }
        <D.31240>:
        <D.31237>:
        <D.31234>:
        <D.31232>:
        <D.31229>:
      }
      i = i + 1;
      <D.27815>:
      D.31257 = header->num_clauses;
      D.31258 = (int) D.31257;
      if (D.31258 > i) goto <D.27814>; else goto <D.27816>;
      <D.27816>:
      goto <D.31259>;
      <D.31041>:
      D.31260 = (long unsigned int) num_args;
      D.31261 = D.31260 * 8;
      arg_array = __builtin_alloca (D.31261);
      cfg->cbb = start_bblock;
      cfg->args = arg_array;
      mono_save_args (cfg, sig, inline_args);
      <D.31259>:
      D.30941 = cfg->mempool;
      bblock.69 = mono_mempool_alloc0 (D.30941, 296);
      bblock = bblock.69;
      bblock.70 = bblock;
      D.31048 = cfg->num_bblocks;
      D.31264 = D.31048;
      D.31265 = D.31264 + 1;
      cfg->num_bblocks = D.31265;
      D.31266 = (int) D.31264;
      bblock.70->block_num = D.31266;
      bblock.70 = bblock;
      bblock.70->cil_code = ip;
      bblock.70 = bblock;
      cfg->cbb = bblock.70;
      cfg->ip = ip;
      bblock.70 = bblock;
      D.31267 = bblock.70->cil_code;
      if (D.31267 != 0B) goto <D.31268>; else goto <D.31269>;
      <D.31268>:
      D.31071 = cfg->cil_offset_to_bb;
      bblock.70 = bblock;
      D.31267 = bblock.70->cil_code;
      D.31270 = (long int) D.31267;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31271 = D.31270 - D.31077;
      D.31272 = (long unsigned int) D.31271;
      D.31273 = D.31272 * 8;
      D.31274 = D.31071 + D.31273;
      bblock.70 = bblock;
      *D.31274 = bblock.70;
      <D.31269>:
      bblock.70 = bblock;
      D.31108 = cfg->real_offset;
      bblock.70->real_offset = D.31108;
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31275>; else goto <D.31276>;
      <D.31275>:
      breakpoint_id = mono_debugger_method_has_breakpoint (method);
      if (breakpoint_id != 0) goto <D.31277>; else goto <D.31278>;
      <D.31277>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 445;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.31280>; else goto <D.31281>;
      <D.31280>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.31282>;
      <D.31281>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.31282>:
      <D.31278>:
      <D.31276>:
      D.31283 = mono_security_get_mode ();
      if (D.31283 == 2) goto <D.31284>; else goto <D.31285>;
      <D.31284>:
      secman = mono_security_manager_get_methods ();
      <D.31285>:
      if (secman != 0B) goto <D.31289>; else goto <D.31287>;
      <D.31289>:
      D.31290 = mono_method_has_declsec (method);
      if (D.31290 != 0) goto <D.31291>; else goto <D.31287>;
      <D.31291>:
      iftmp.71 = 1;
      goto <D.31288>;
      <D.31287>:
      iftmp.71 = 0;
      <D.31288>:
      security = (MonoBoolean) iftmp.71;
      if (security != 0) goto <D.31292>; else goto <D.31293>;
      <D.31292>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31294>; else goto <D.31295>;
      <D.31294>:
      security = mono_declsec_get_demands (method, &actions);
      <D.31295>:
      <D.31293>:
      if (secman != 0B) goto <D.31299>; else goto <D.31297>;
      <D.31299>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 24) goto <D.31300>; else goto <D.31297>;
      <D.31300>:
      iftmp.72 = 1;
      goto <D.31298>;
      <D.31297>:
      iftmp.72 = 0;
      <D.31298>:
      pinvoke = (MonoBoolean) iftmp.72;
      if (pinvoke != 0) goto <D.31301>; else goto <D.31302>;
      <D.31301>:
      {
        struct MonoMethod * wrapped;

        wrapped = mono_marshal_method_from_wrapper (method);
        if (wrapped != 0B) goto <D.31305>; else goto <D.31303>;
        <D.31305>:
        D.31306 = wrapped->flags;
        D.31307 = (int) D.31306;
        D.31308 = D.31307 & 8192;
        if (D.31308 != 0) goto <D.31309>; else goto <D.31303>;
        <D.31309>:
        {
          struct MonoCustomAttrInfo * custom;

          custom = mono_custom_attrs_from_method (wrapped);
          if (custom != 0B) goto <D.31310>; else goto <D.31311>;
          <D.31310>:
          D.31312 = secman->suppressunmanagedcodesecurity;
          D.31313 = mono_custom_attrs_has_attr (custom, D.31312);
          if (D.31313 != 0) goto <D.31314>; else goto <D.31315>;
          <D.31314>:
          pinvoke = 0;
          <D.31315>:
          <D.31311>:
          if (custom != 0B) goto <D.31316>; else goto <D.31317>;
          <D.31316>:
          mono_custom_attrs_free (custom);
          <D.31317>:
          if (pinvoke != 0) goto <D.31318>; else goto <D.31319>;
          <D.31318>:
          D.31320 = wrapped->klass;
          custom = mono_custom_attrs_from_class (D.31320);
          if (custom != 0B) goto <D.31321>; else goto <D.31322>;
          <D.31321>:
          D.31312 = secman->suppressunmanagedcodesecurity;
          D.31323 = mono_custom_attrs_has_attr (custom, D.31312);
          if (D.31323 != 0) goto <D.31324>; else goto <D.31325>;
          <D.31324>:
          pinvoke = 0;
          <D.31325>:
          <D.31322>:
          if (custom != 0B) goto <D.31326>; else goto <D.31327>;
          <D.31326>:
          mono_custom_attrs_free (custom);
          <D.31327>:
          <D.31319>:
        }
        goto <D.31304>;
        <D.31303>:
        pinvoke = 0;
        <D.31304>:
      }
      <D.31302>:
      if (init_locals != 0) goto <D.31328>; else goto <D.31332>;
      <D.31332>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31333>; else goto <D.31329>;
      <D.31333>:
      D.31334 = cfg->opt;
      D.31335 = D.31334 & 512;
      if (D.31335 != 0) goto <D.31328>; else goto <D.31329>;
      <D.31329>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31337 = D.31336 & 274877906944;
      if (D.31337 != 0) goto <D.31328>; else goto <D.31338>;
      <D.31338>:
      D.31339 = security | pinvoke;
      if (D.31339 != 0) goto <D.31328>; else goto <D.31330>;
      <D.31328>:
      D.30941 = cfg->mempool;
      init_localsbb = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.31340 = D.31048;
      D.31341 = D.31340 + 1;
      cfg->num_bblocks = D.31341;
      D.31342 = (int) D.31340;
      init_localsbb->block_num = D.31342;
      cfg->bb_init = init_localsbb;
      D.31108 = cfg->real_offset;
      init_localsbb->real_offset = D.31108;
      start_bblock->next_bb = init_localsbb;
      bblock.70 = bblock;
      init_localsbb->next_bb = bblock.70;
      link_bblock (cfg, start_bblock, init_localsbb);
      bblock.70 = bblock;
      link_bblock (cfg, init_localsbb, bblock.70);
      cfg->cbb = init_localsbb;
      goto <D.31331>;
      <D.31330>:
      bblock.70 = bblock;
      start_bblock->next_bb = bblock.70;
      bblock.70 = bblock;
      link_bblock (cfg, start_bblock, bblock.70);
      <D.31331>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31343>; else goto <D.31344>;
      <D.31343>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31345>; else goto <D.31346>;
      <D.31345>:
      {
        struct MonoGSharedVtMethodInfo * info;
        struct MonoInst * var;
        struct MonoInst * locals_var;
        int dreg;

        D.30941 = cfg->mempool;
        info = mono_mempool_alloc0 (D.30941, 16);
        D.30911 = cfg->method;
        info->method = D.30911;
        D.31347 = monoeg_g_ptr_array_new ();
        info->entries = D.31347;
        cfg->gsharedvt_info = info;
        D.31348 = mono_defaults.int_class;
        D.31349 = &D.31348->byval_arg;
        var = mono_compile_create_var (cfg, D.31349, 329);
        cfg->gsharedvt_info_var = var;
        D.31350 = mini_method_check_context_used (cfg, method);
        ins = emit_get_rgctx_gsharedvt_method (cfg, D.31350, method, info);
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31351 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31351;
          inst->prev = 0B;
          D.31352 = inst->prev;
          inst->next = D.31352;
          inst->opcode = 424;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31353 = inst->sreg3;
          inst->sreg2 = D.31353;
          D.31354 = inst->sreg2;
          inst->sreg1 = D.31354;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.31355 = var->dreg;
          inst->dreg = D.31355;
          D.31356 = ins->dreg;
          inst->sreg1 = D.31356;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31357>; else goto <D.31358>;
          <D.31357>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31359>;
          <D.31358>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31359>:
        }
        D.31348 = mono_defaults.int_class;
        D.31349 = &D.31348->byval_arg;
        locals_var = mono_compile_create_var (cfg, D.31349, 329);
        cfg->gsharedvt_locals_var = locals_var;
        D.31360 = alloc_ireg (cfg);
        dreg = (int) D.31360;
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31361 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31361;
          inst->prev = 0B;
          D.31362 = inst->prev;
          inst->next = D.31362;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31363 = inst->sreg3;
          inst->sreg2 = D.31363;
          D.31364 = inst->sreg2;
          inst->sreg1 = D.31364;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = dreg;
          D.31355 = var->dreg;
          inst->sreg1 = D.31355;
          inst->data.op[0].const_val = 0;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31365>; else goto <D.31366>;
          <D.31365>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31367>;
          <D.31366>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31367>:
        }
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 338;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31368 = locals_var->dreg;
        ins->dreg = D.31368;
        ins->sreg1 = dreg;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.31369>; else goto <D.31370>;
        <D.31369>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.31371>;
        <D.31370>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.31371>:
        cfg->gsharedvt_locals_var_ins = ins;
        D.31372 = cfg->flags;
        D.31373 = D.31372 | 1;
        cfg->flags = D.31373;
      }
      <D.31346>:
      <D.31344>:
      if (security != 0) goto <D.31374>; else goto <D.31375>;
      <D.31374>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31376>; else goto <D.31377>;
      <D.31376>:
      {
        struct MonoInst * args[2];

        try
          {
            D.31378 = cfg->stat_cas_demand_generation;
            D.31379 = D.31378 + 1;
            cfg->stat_cas_demand_generation = D.31379;
            D.31380 = actions.demand.blob;
            if (D.31380 != 0B) goto <D.31381>; else goto <D.31382>;
            <D.31381>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.31383>; else goto <D.31384>;
            <D.31383>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              D.30941 = cfg->mempool;
              D.31385 = mono_mempool_alloc (D.30941, 80);
              args[0] = D.31385;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->data.op[1].const_val = 0;
              D.31387 = D.31386->data.op[1].const_val;
              D.31386->data.op[0].const_val = D.31387;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->prev = 0B;
              D.31388 = D.31386->prev;
              D.31386->next = D.31388;
              D.31386 = args[0];
              D.31386->opcode = 734;
              D.31386 = args[0];
              D.31386->flags = 0;
              D.31386 = args[0];
              D.31386->type = 0;
              D.31386 = args[0];
              D.31386->dreg = -1;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->sreg3 = -1;
              D.31389 = D.31386->sreg3;
              D.31386->sreg2 = D.31389;
              D.31390 = D.31386->sreg2;
              D.31386->sreg1 = D.31390;
              D.31386 = args[0];
              D.31162 = cfg->ip;
              D.31386->cil_code = D.31162;
              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.31391 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.31391;
              group->prev = 0B;
              D.31392 = group->prev;
              group->next = D.31392;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.31393 = group->sreg3;
              group->sreg2 = D.31393;
              D.31394 = group->sreg2;
              group->sreg1 = D.31394;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 28B;
              D.30941 = cfg->mempool;
              D.31395 = actions.demand.index;
              D.31396 = mono_jump_info_token_new2 (D.30941, image, D.31395, 0B);
              group->data.op[0].p = D.31396;
              D.31386 = args[0];
              D.31397 = got_loc->dreg;
              D.31386->sreg1 = D.31397;
              D.31386 = args[0];
              D.31386->data.op[1].p = group;
              D.31386 = args[0];
              D.31386->type = 6;
              D.31386 = args[0];
              D.31386->klass = 0B;
              D.31386 = args[0];
              D.31398 = alloc_dreg (cfg, 6);
              D.31399 = (int) D.31398;
              D.31386->dreg = D.31399;
            }
            goto <D.31400>;
            <D.31384>:
            D.30941 = cfg->mempool;
            D.31401 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.31401;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->data.op[1].const_val = 0;
            D.31387 = D.31386->data.op[1].const_val;
            D.31386->data.op[0].const_val = D.31387;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->prev = 0B;
            D.31388 = D.31386->prev;
            D.31386->next = D.31388;
            D.31386 = args[0];
            D.31386->opcode = 363;
            D.31386 = args[0];
            D.31386->flags = 0;
            D.31386 = args[0];
            D.31386->type = 0;
            D.31386 = args[0];
            D.31386->dreg = -1;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->sreg3 = -1;
            D.31389 = D.31386->sreg3;
            D.31386->sreg2 = D.31389;
            D.31390 = D.31386->sreg2;
            D.31386->sreg1 = D.31390;
            D.31386 = args[0];
            D.31162 = cfg->ip;
            D.31386->cil_code = D.31162;
            D.31386 = args[0];
            D.31380 = actions.demand.blob;
            D.31386->data.op[0].p = D.31380;
            D.31386 = args[0];
            D.31386->type = 3;
            D.31386 = args[0];
            D.31402 = alloc_dreg (cfg, 3);
            D.31403 = (int) D.31402;
            D.31386->dreg = D.31403;
            <D.31400>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31404>; else goto <D.31405>;
            <D.31404>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386 = args[0];
            D.31191->next = D.31386;
            D.31386 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            goto <D.31406>;
            <D.31405>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31406>:
            D.30941 = cfg->mempool;
            D.31407 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.31407;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->data.op[1].const_val = 0;
            D.31409 = D.31408->data.op[1].const_val;
            D.31408->data.op[0].const_val = D.31409;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->prev = 0B;
            D.31410 = D.31408->prev;
            D.31408->next = D.31410;
            D.31408 = args[1];
            D.31408->opcode = 362;
            D.31408 = args[1];
            D.31408->flags = 0;
            D.31408 = args[1];
            D.31408->type = 0;
            D.31408 = args[1];
            D.31408->dreg = -1;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->sreg3 = -1;
            D.31411 = D.31408->sreg3;
            D.31408->sreg2 = D.31411;
            D.31412 = D.31408->sreg2;
            D.31408->sreg1 = D.31412;
            D.31408 = args[1];
            D.31162 = cfg->ip;
            D.31408->cil_code = D.31162;
            D.31408 = args[1];
            D.31413 = actions.demand.size;
            D.31414 = (long int) D.31413;
            D.31408->data.op[0].const_val = D.31414;
            D.31408 = args[1];
            D.31408->type = 1;
            D.31408 = args[1];
            D.31415 = alloc_dreg (cfg, 1);
            D.31416 = (int) D.31415;
            D.31408->dreg = D.31416;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31417>; else goto <D.31418>;
            <D.31417>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408 = args[1];
            D.31191->next = D.31408;
            D.31408 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            goto <D.31419>;
            <D.31418>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31419>:
            D.31420 = secman->demand;
            mono_emit_method_call (cfg, D.31420, &args, 0B);
            <D.31382>:
            D.31421 = actions.noncasdemand.blob;
            if (D.31421 != 0B) goto <D.31422>; else goto <D.31423>;
            <D.31422>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.31424>; else goto <D.31425>;
            <D.31424>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              D.30941 = cfg->mempool;
              D.31426 = mono_mempool_alloc (D.30941, 80);
              args[0] = D.31426;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->data.op[1].const_val = 0;
              D.31387 = D.31386->data.op[1].const_val;
              D.31386->data.op[0].const_val = D.31387;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->prev = 0B;
              D.31388 = D.31386->prev;
              D.31386->next = D.31388;
              D.31386 = args[0];
              D.31386->opcode = 734;
              D.31386 = args[0];
              D.31386->flags = 0;
              D.31386 = args[0];
              D.31386->type = 0;
              D.31386 = args[0];
              D.31386->dreg = -1;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->sreg3 = -1;
              D.31389 = D.31386->sreg3;
              D.31386->sreg2 = D.31389;
              D.31390 = D.31386->sreg2;
              D.31386->sreg1 = D.31390;
              D.31386 = args[0];
              D.31162 = cfg->ip;
              D.31386->cil_code = D.31162;
              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.31427 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.31427;
              group->prev = 0B;
              D.31428 = group->prev;
              group->next = D.31428;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.31429 = group->sreg3;
              group->sreg2 = D.31429;
              D.31430 = group->sreg2;
              group->sreg1 = D.31430;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 28B;
              D.30941 = cfg->mempool;
              D.31431 = actions.noncasdemand.index;
              D.31432 = mono_jump_info_token_new2 (D.30941, image, D.31431, 0B);
              group->data.op[0].p = D.31432;
              D.31386 = args[0];
              D.31433 = got_loc->dreg;
              D.31386->sreg1 = D.31433;
              D.31386 = args[0];
              D.31386->data.op[1].p = group;
              D.31386 = args[0];
              D.31386->type = 6;
              D.31386 = args[0];
              D.31386->klass = 0B;
              D.31386 = args[0];
              D.31434 = alloc_dreg (cfg, 6);
              D.31435 = (int) D.31434;
              D.31386->dreg = D.31435;
            }
            goto <D.31436>;
            <D.31425>:
            D.30941 = cfg->mempool;
            D.31437 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.31437;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->data.op[1].const_val = 0;
            D.31387 = D.31386->data.op[1].const_val;
            D.31386->data.op[0].const_val = D.31387;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->prev = 0B;
            D.31388 = D.31386->prev;
            D.31386->next = D.31388;
            D.31386 = args[0];
            D.31386->opcode = 363;
            D.31386 = args[0];
            D.31386->flags = 0;
            D.31386 = args[0];
            D.31386->type = 0;
            D.31386 = args[0];
            D.31386->dreg = -1;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->sreg3 = -1;
            D.31389 = D.31386->sreg3;
            D.31386->sreg2 = D.31389;
            D.31390 = D.31386->sreg2;
            D.31386->sreg1 = D.31390;
            D.31386 = args[0];
            D.31162 = cfg->ip;
            D.31386->cil_code = D.31162;
            D.31386 = args[0];
            D.31421 = actions.noncasdemand.blob;
            D.31386->data.op[0].p = D.31421;
            D.31386 = args[0];
            D.31386->type = 3;
            D.31386 = args[0];
            D.31438 = alloc_dreg (cfg, 3);
            D.31439 = (int) D.31438;
            D.31386->dreg = D.31439;
            <D.31436>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31440>; else goto <D.31441>;
            <D.31440>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386 = args[0];
            D.31191->next = D.31386;
            D.31386 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            goto <D.31442>;
            <D.31441>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31442>:
            D.30941 = cfg->mempool;
            D.31443 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.31443;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->data.op[1].const_val = 0;
            D.31409 = D.31408->data.op[1].const_val;
            D.31408->data.op[0].const_val = D.31409;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->prev = 0B;
            D.31410 = D.31408->prev;
            D.31408->next = D.31410;
            D.31408 = args[1];
            D.31408->opcode = 362;
            D.31408 = args[1];
            D.31408->flags = 0;
            D.31408 = args[1];
            D.31408->type = 0;
            D.31408 = args[1];
            D.31408->dreg = -1;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->sreg3 = -1;
            D.31411 = D.31408->sreg3;
            D.31408->sreg2 = D.31411;
            D.31412 = D.31408->sreg2;
            D.31408->sreg1 = D.31412;
            D.31408 = args[1];
            D.31162 = cfg->ip;
            D.31408->cil_code = D.31162;
            D.31408 = args[1];
            D.31444 = actions.noncasdemand.size;
            D.31445 = (long int) D.31444;
            D.31408->data.op[0].const_val = D.31445;
            D.31408 = args[1];
            D.31408->type = 1;
            D.31408 = args[1];
            D.31446 = alloc_dreg (cfg, 1);
            D.31447 = (int) D.31446;
            D.31408->dreg = D.31447;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31448>; else goto <D.31449>;
            <D.31448>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408 = args[1];
            D.31191->next = D.31408;
            D.31408 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            goto <D.31450>;
            <D.31449>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31450>:
            D.31420 = secman->demand;
            mono_emit_method_call (cfg, D.31420, &args, 0B);
            <D.31423>:
            D.31451 = actions.demandchoice.blob;
            if (D.31451 != 0B) goto <D.31452>; else goto <D.31453>;
            <D.31452>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.31454>; else goto <D.31455>;
            <D.31454>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              D.30941 = cfg->mempool;
              D.31456 = mono_mempool_alloc (D.30941, 80);
              args[0] = D.31456;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->data.op[1].const_val = 0;
              D.31387 = D.31386->data.op[1].const_val;
              D.31386->data.op[0].const_val = D.31387;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->prev = 0B;
              D.31388 = D.31386->prev;
              D.31386->next = D.31388;
              D.31386 = args[0];
              D.31386->opcode = 734;
              D.31386 = args[0];
              D.31386->flags = 0;
              D.31386 = args[0];
              D.31386->type = 0;
              D.31386 = args[0];
              D.31386->dreg = -1;
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386 = args[0];
              D.31386->sreg3 = -1;
              D.31389 = D.31386->sreg3;
              D.31386->sreg2 = D.31389;
              D.31390 = D.31386->sreg2;
              D.31386->sreg1 = D.31390;
              D.31386 = args[0];
              D.31162 = cfg->ip;
              D.31386->cil_code = D.31162;
              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.31457 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.31457;
              group->prev = 0B;
              D.31458 = group->prev;
              group->next = D.31458;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.31459 = group->sreg3;
              group->sreg2 = D.31459;
              D.31460 = group->sreg2;
              group->sreg1 = D.31460;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 28B;
              D.30941 = cfg->mempool;
              D.31461 = actions.demandchoice.index;
              D.31462 = mono_jump_info_token_new2 (D.30941, image, D.31461, 0B);
              group->data.op[0].p = D.31462;
              D.31386 = args[0];
              D.31463 = got_loc->dreg;
              D.31386->sreg1 = D.31463;
              D.31386 = args[0];
              D.31386->data.op[1].p = group;
              D.31386 = args[0];
              D.31386->type = 6;
              D.31386 = args[0];
              D.31386->klass = 0B;
              D.31386 = args[0];
              D.31464 = alloc_dreg (cfg, 6);
              D.31465 = (int) D.31464;
              D.31386->dreg = D.31465;
            }
            goto <D.31466>;
            <D.31455>:
            D.30941 = cfg->mempool;
            D.31467 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.31467;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->data.op[1].const_val = 0;
            D.31387 = D.31386->data.op[1].const_val;
            D.31386->data.op[0].const_val = D.31387;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->prev = 0B;
            D.31388 = D.31386->prev;
            D.31386->next = D.31388;
            D.31386 = args[0];
            D.31386->opcode = 363;
            D.31386 = args[0];
            D.31386->flags = 0;
            D.31386 = args[0];
            D.31386->type = 0;
            D.31386 = args[0];
            D.31386->dreg = -1;
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386 = args[0];
            D.31386->sreg3 = -1;
            D.31389 = D.31386->sreg3;
            D.31386->sreg2 = D.31389;
            D.31390 = D.31386->sreg2;
            D.31386->sreg1 = D.31390;
            D.31386 = args[0];
            D.31162 = cfg->ip;
            D.31386->cil_code = D.31162;
            D.31386 = args[0];
            D.31451 = actions.demandchoice.blob;
            D.31386->data.op[0].p = D.31451;
            D.31386 = args[0];
            D.31386->type = 3;
            D.31386 = args[0];
            D.31468 = alloc_dreg (cfg, 3);
            D.31469 = (int) D.31468;
            D.31386->dreg = D.31469;
            <D.31466>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31470>; else goto <D.31471>;
            <D.31470>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386 = args[0];
            D.31191->next = D.31386;
            D.31386 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31386->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            goto <D.31472>;
            <D.31471>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31386 = args[0];
            bblock.113->last_ins = D.31386;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31472>:
            D.30941 = cfg->mempool;
            D.31473 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.31473;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->data.op[1].const_val = 0;
            D.31409 = D.31408->data.op[1].const_val;
            D.31408->data.op[0].const_val = D.31409;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->prev = 0B;
            D.31410 = D.31408->prev;
            D.31408->next = D.31410;
            D.31408 = args[1];
            D.31408->opcode = 362;
            D.31408 = args[1];
            D.31408->flags = 0;
            D.31408 = args[1];
            D.31408->type = 0;
            D.31408 = args[1];
            D.31408->dreg = -1;
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408 = args[1];
            D.31408->sreg3 = -1;
            D.31411 = D.31408->sreg3;
            D.31408->sreg2 = D.31411;
            D.31412 = D.31408->sreg2;
            D.31408->sreg1 = D.31412;
            D.31408 = args[1];
            D.31162 = cfg->ip;
            D.31408->cil_code = D.31162;
            D.31408 = args[1];
            D.31474 = actions.demandchoice.size;
            D.31475 = (long int) D.31474;
            D.31408->data.op[0].const_val = D.31475;
            D.31408 = args[1];
            D.31408->type = 1;
            D.31408 = args[1];
            D.31476 = alloc_dreg (cfg, 1);
            D.31477 = (int) D.31476;
            D.31408->dreg = D.31477;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.31478>; else goto <D.31479>;
            <D.31478>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408 = args[1];
            D.31191->next = D.31408;
            D.31408 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31408->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            goto <D.31480>;
            <D.31479>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31408 = args[1];
            bblock.113->last_ins = D.31408;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.31480>:
            D.31481 = secman->demandchoice;
            mono_emit_method_call (cfg, D.31481, &args, 0B);
            <D.31453>:
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.31377>:
      <D.31375>:
      if (pinvoke != 0) goto <D.31482>; else goto <D.31483>;
      <D.31482>:
      D.31484 = secman->demandunmanaged;
      mono_emit_method_call (cfg, D.31484, 0B, 0B);
      <D.31483>:
      D.31485 = mono_security_get_mode ();
      if (D.31485 == 1) goto <D.31486>; else goto <D.31487>;
      <D.31486>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 24) goto <D.31488>; else goto <D.31489>;
      <D.31488>:
      {
        struct MonoMethod * wrapped;

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

          D.31492 = wrapped->flags;
          D.31493 = (int) D.31492;
          pinvk = D.31493 & 8192;
          D.31494 = wrapped->iflags;
          D.31495 = (int) D.31494;
          icall = D.31495 & 4096;
          D.31496 = icall | pinvk;
          if (D.31496 != 0) goto <D.31497>; else goto <D.31498>;
          <D.31497>:
          D.30878 = method->klass;
          if (D.30878 != 0B) goto <D.31499>; else goto <D.31500>;
          <D.31499>:
          D.30878 = method->klass;
          D.30879 = D.30878->image;
          if (D.30879 != 0B) goto <D.31501>; else goto <D.31502>;
          <D.31501>:
          D.30878 = method->klass;
          D.30879 = D.30878->image;
          D.31503 = mono_security_core_clr_is_platform_image (D.30879);
          if (D.31503 == 0) goto <D.31504>; else goto <D.31505>;
          <D.31504>:
          {
            struct MonoException * ex;

            if (icall != 0) goto <D.31507>; else goto <D.31508>;
            <D.31507>:
            iftmp.73 = mono_get_exception_security ();
            goto <D.31509>;
            <D.31508>:
            iftmp.73 = mono_get_exception_method_access ();
            <D.31509>:
            ex = iftmp.73;
            emit_throw_exception (cfg, ex);
          }
          <D.31505>:
          <D.31502>:
          <D.31500>:
          <D.31498>:
        }
        <D.31491>:
      }
      <D.31489>:
      <D.31487>:
      D.31510 = cfg->exception_type;
      if (D.31510 != 0) goto exception_exit; else goto <D.31511>;
      <D.31511>:
      D.30919 = header->code_size;
      if (D.30919 == 0) goto <D.31512>; else goto <D.31513>;
      <D.31512>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31514>; else goto <D.31515>;
      <D.31514>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31516>; else goto <D.31517>;
      <D.31516>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31517>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31515>:
      D.31518 = mini_get_debug_options ();
      D.31519 = D.31518->break_on_unverified;
      if (D.31519 != 0) goto <D.31520>; else goto unverified;
      <D.31520>:
      raise (5);
      <D.31513>:
      D.31108 = cfg->real_offset;
      D.31521 = get_basic_blocks (cfg, header, D.31108, ip, end, &err_pos);
      if (D.31521 != 0) goto <D.31522>; else goto <D.31523>;
      <D.31522>:
      ip = err_pos;
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31524>; else goto <D.31525>;
      <D.31524>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31526>; else goto <D.31527>;
      <D.31526>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31527>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31525>:
      D.31528 = mini_get_debug_options ();
      D.31529 = D.31528->break_on_unverified;
      if (D.31529 != 0) goto <D.31530>; else goto unverified;
      <D.31530>:
      raise (5);
      <D.31523>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31531>; else goto <D.31532>;
      <D.31531>:
      bblock.70 = bblock;
      breakpoint_id.74 = (unsigned int) breakpoint_id;
      mono_debug_init_method (cfg, bblock.70, breakpoint_id.74);
      <D.31532>:
      n = 0;
      goto <D.27837>;
      <D.27836>:
      D.31534 = header->locals[n];
      D.31535 = BIT_FIELD_REF <*D.31534, 64, 64>;
      D.31536 = D.31535 & 1090453504;
      if (D.31536 == 65536) goto <D.31537>; else goto <D.31538>;
      <D.31537>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31539>; else goto <D.31540>;
      <D.31539>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31541>; else goto <D.31542>;
      <D.31541>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31542>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31540>:
      D.31543 = mini_get_debug_options ();
      D.31544 = D.31543->break_on_unverified;
      if (D.31544 != 0) goto <D.31545>; else goto unverified;
      <D.31545>:
      raise (5);
      <D.31538>:
      n = n + 1;
      <D.27837>:
      D.31546 = header->num_locals;
      D.31547 = (int) D.31546;
      if (D.31547 > n) goto <D.27836>; else goto <D.27838>;
      <D.27838>:
      class_inits = 0B;
      D.30977 = cfg->generic_sharing_context;
      if (D.30977 != 0B) goto <D.31548>; else goto <D.31549>;
      <D.31548>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31550>; else goto <D.31551>;
      <D.31550>:
      D.31241 = method->flags;
      D.31242 = (int) D.31241;
      D.31243 = D.31242 & 16;
      if (D.31243 != 0) goto <D.31552>; else goto <D.31555>;
      <D.31555>:
      D.31556 = mini_method_get_context (method);
      D.31557 = D.31556->method_inst;
      if (D.31557 != 0B) goto <D.31552>; else goto <D.31558>;
      <D.31558>:
      D.30878 = method->klass;
      D.31030 = BIT_FIELD_REF <*D.30878, 64, 256>;
      D.31031 = D.31030 & 8;
      if (D.31031 != 0) goto <D.31552>; else goto <D.31553>;
      <D.31552>:
      mono_get_vtable_var (cfg);
      goto <D.31554>;
      <D.31553>:
      D.31559 = cfg->args;
      D.31560 = *D.31559;
      D.31559 = cfg->args;
      D.31560 = *D.31559;
      D.31561 = D.31560->flags;
      D.31562 = D.31561 | 4;
      D.31560->flags = D.31562;
      <D.31554>:
      <D.31551>:
      <D.31549>:
      if (is_virtual_call != 0) goto <D.31563>; else goto <D.31564>;
      <D.31563>:
      {
        struct MonoInst * arg_ins;

        D.30941 = cfg->mempool;
        arg_ins = mono_mempool_alloc (D.30941, 80);
        arg_ins->data.op[1].const_val = 0;
        D.31565 = arg_ins->data.op[1].const_val;
        arg_ins->data.op[0].const_val = D.31565;
        arg_ins->prev = 0B;
        D.31566 = arg_ins->prev;
        arg_ins->next = D.31566;
        arg_ins->opcode = 424;
        arg_ins->flags = 0;
        arg_ins->type = 0;
        arg_ins->dreg = -1;
        arg_ins->sreg3 = -1;
        D.31567 = arg_ins->sreg3;
        arg_ins->sreg2 = D.31567;
        D.31568 = arg_ins->sreg2;
        arg_ins->sreg1 = D.31568;
        D.31162 = cfg->ip;
        arg_ins->cil_code = D.31162;
        D.31569 = cfg->arg_types;
        D.31570 = *D.31569;
        D.31571 = mono_type_to_regmove (cfg, D.31570);
        D.31572 = (short unsigned int) D.31571;
        arg_ins->opcode = D.31572;
        D.31569 = cfg->arg_types;
        D.31570 = *D.31569;
        type_to_eval_stack_type (cfg, D.31570, arg_ins);
        D.31559 = cfg->args;
        D.31560 = *D.31559;
        D.31573 = D.31560->klass;
        arg_ins->klass = D.31573;
        D.31559 = cfg->args;
        D.31560 = *D.31559;
        D.31574 = D.31560->dreg;
        arg_ins->sreg1 = D.31574;
        D.31575 = arg_ins->type;
        D.31576 = (<unnamed type>) D.31575;
        D.31577 = alloc_dreg (cfg, D.31576);
        D.31578 = (int) D.31577;
        arg_ins->dreg = D.31578;
        D.31579 = arg_ins->opcode;
        if (D.31579 == 427) goto <D.31580>; else goto <D.31581>;
        <D.31580>:
        D.31569 = cfg->arg_types;
        D.31570 = *D.31569;
        D.31582 = mono_class_from_mono_type (D.31570);
        arg_ins->klass = D.31582;
        <D.31581>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.31583>; else goto <D.31584>;
        <D.31583>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = arg_ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        arg_ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = arg_ins;
        goto <D.31585>;
        <D.31584>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = arg_ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.31585>:
        D.31372 = cfg->flags;
        D.31586 = D.31372 | 128;
        cfg->flags = D.31586;
        D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.31587 = D.30929 & 64;
        if (D.31587 != 0) goto <D.31588>; else goto <D.31589>;
        <D.31588>:
        D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.31587 = D.30929 & 64;
        if (D.31587 != 0) goto <D.31590>; else goto <D.31591>;
        <D.31590>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31592 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31592;
          inst->prev = 0B;
          D.31593 = inst->prev;
          inst->next = D.31593;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31594 = inst->sreg3;
          inst->sreg2 = D.31594;
          D.31595 = inst->sreg2;
          inst->sreg1 = D.31595;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          D.31596 = arg_ins->dreg;
          inst->sreg1 = D.31596;
          inst->data.op[1].const_val = 0;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31597>; else goto <D.31598>;
          <D.31597>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31599>;
          <D.31598>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31599>:
        }
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31600 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31600;
          inst->prev = 0B;
          D.31601 = inst->prev;
          inst->next = D.31601;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31602 = inst->sreg3;
          inst->sreg2 = D.31602;
          D.31603 = inst->sreg2;
          inst->sreg1 = D.31603;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->data.op[1].p = "NullReferenceException";
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31604>; else goto <D.31605>;
          <D.31604>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31606>;
          <D.31605>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31606>:
        }
        goto <D.31607>;
        <D.31591>:
        <D.31607>:
        goto <D.31608>;
        <D.31589>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31609 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31609;
          inst->prev = 0B;
          D.31610 = inst->prev;
          inst->next = D.31610;
          inst->opcode = 340;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31611 = inst->sreg3;
          inst->sreg2 = D.31611;
          D.31612 = inst->sreg2;
          inst->sreg1 = D.31612;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          D.31596 = arg_ins->dreg;
          inst->sreg1 = D.31596;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31613>; else goto <D.31614>;
          <D.31613>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31615>;
          <D.31614>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31615>:
        }
        <D.31608>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31616 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31616;
          inst->prev = 0B;
          D.31617 = inst->prev;
          inst->next = D.31617;
          inst->opcode = 799;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31618 = inst->sreg3;
          inst->sreg2 = D.31618;
          D.31619 = inst->sreg2;
          inst->sreg1 = D.31619;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          D.31596 = arg_ins->dreg;
          inst->sreg1 = D.31596;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31620>; else goto <D.31621>;
          <D.31620>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31622>;
          <D.31621>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31622>:
        }
      }
      <D.31564>:
      D.31623 = dont_verify == 0;
      skip_dead_blocks = (gboolean) D.31623;
      if (skip_dead_blocks != 0) goto <D.31624>; else goto <D.31625>;
      <D.31624>:
      bb = mono_basic_block_split (method, &error);
      original_bb = bb;
      D.31626 = mono_error_ok (&error);
      if (D.31626 == 0) goto <D.31627>; else goto <D.31628>;
      <D.31627>:
      mono_error_cleanup (&error);
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31629>; else goto <D.31630>;
      <D.31629>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31631>; else goto <D.31632>;
      <D.31631>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31632>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31630>:
      D.31633 = mini_get_debug_options ();
      D.31634 = D.31633->break_on_unverified;
      if (D.31634 != 0) goto <D.31635>; else goto unverified;
      <D.31635>:
      raise (5);
      <D.31628>:
      D.31636 = bb == 0B;
      D.31637 = (long int) D.31636;
      D.31638 = __builtin_expect (D.31637, 0);
      if (D.31638 != 0) goto <D.31639>; else goto <D.31640>;
      <D.31639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7115, "bb");
      <D.31640>:
      <D.31625>:
      D.30941 = cfg->mempool;
      D.31641 = header->max_stack;
      D.31642 = (int) D.31641;
      D.31643 = D.31642 + 1;
      D.31644 = (long unsigned int) D.31643;
      D.31645 = (unsigned int) D.31644;
      D.31646 = D.31645 * 8;
      sp = mono_mempool_alloc0 (D.30941, D.31646);
      stack_start = sp;
      ins_flag = 0;
      start_new_bblock = 0;
      bblock.70 = bblock;
      cfg->cbb = bblock.70;
      goto <D.27852>;
      <D.28765>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31647>; else goto <D.31648>;
      <D.31647>:
      ip.75 = (long int) ip;
      D.31088 = header->code;
      D.31650 = (long int) D.31088;
      D.31651 = ip.75 - D.31650;
      D.31652 = (unsigned int) D.31651;
      cfg->real_offset = D.31652;
      goto <D.31653>;
      <D.31648>:
      cfg->real_offset = inline_offset;
      <D.31653>:
      cfg->ip = ip;
      context_used = 0;
      if (start_new_bblock != 0) goto <D.31654>; else goto <D.31655>;
      <D.31654>:
      bblock.70 = bblock;
      ip.75 = (long int) ip;
      bblock.70 = bblock;
      D.31267 = bblock.70->cil_code;
      D.31270 = (long int) D.31267;
      D.31656 = ip.75 - D.31270;
      D.31657 = (int) D.31656;
      bblock.70->cil_length = D.31657;
      if (start_new_bblock == 2) goto <D.31658>; else goto <D.31659>;
      <D.31658>:
      D.31138 = tblock->cil_code;
      D.31660 = D.31138 != ip;
      D.31661 = (long int) D.31660;
      D.31662 = __builtin_expect (D.31661, 0);
      if (D.31662 != 0) goto <D.31663>; else goto <D.31664>;
      <D.31663>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7136, "ip == tblock->cil_code");
      <D.31664>:
      goto <D.31665>;
      <D.31659>:
      D.31071 = cfg->cil_offset_to_bb;
      ip.75 = (long int) ip;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31666 = ip.75 - D.31077;
      D.31667 = (long unsigned int) D.31666;
      D.31668 = D.31667 * 8;
      D.31669 = D.31071 + D.31668;
      tblock = *D.31669;
      if (tblock == 0B) goto <D.31670>; else goto <D.31671>;
      <D.31670>:
      if (ip >= end) goto <D.31672>; else goto <D.31674>;
      <D.31674>:
      D.31088 = header->code;
      if (D.31088 > ip) goto <D.31672>; else goto <D.31673>;
      <D.31672>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31675>; else goto <D.31676>;
      <D.31675>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31677>; else goto <D.31678>;
      <D.31677>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31678>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31676>:
      D.31679 = mini_get_debug_options ();
      D.31680 = D.31679->break_on_unverified;
      if (D.31680 != 0) goto <D.31681>; else goto unverified;
      <D.31681>:
      raise (5);
      <D.31673>:
      D.30941 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.31682 = D.31048;
      D.31683 = D.31682 + 1;
      cfg->num_bblocks = D.31683;
      D.31684 = (int) D.31682;
      tblock->block_num = D.31684;
      tblock->cil_code = ip;
      D.31138 = tblock->cil_code;
      if (D.31138 != 0B) goto <D.31685>; else goto <D.31686>;
      <D.31685>:
      D.31071 = cfg->cil_offset_to_bb;
      D.31138 = tblock->cil_code;
      D.31141 = (long int) D.31138;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31142 = D.31141 - D.31077;
      D.31143 = (long unsigned int) D.31142;
      D.31144 = D.31143 * 8;
      D.31145 = D.31071 + D.31144;
      *D.31145 = tblock;
      <D.31686>:
      D.31108 = cfg->real_offset;
      tblock->real_offset = D.31108;
      <D.31671>:
      <D.31665>:
      bblock.70 = bblock;
      bblock.70->next_bb = tblock;
      bblock = tblock;
      bblock.70 = bblock;
      cfg->cbb = bblock.70;
      start_new_bblock = 0;
      i = 0;
      goto <D.27845>;
      <D.27844>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 3) goto <D.31687>; else goto <D.31688>;
      <D.31687>:
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31694 = (int) D.31693;
      printf ("loading %d from temp %d\n", i, D.31694);
      <D.31688>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      D.31701 = mono_type_to_regmove (cfg, D.31700);
      D.31702 = (short unsigned int) D.31701;
      ins->opcode = D.31702;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      type_to_eval_stack_type (cfg, D.31700, ins);
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31703 = D.31699->klass;
      ins->klass = D.31703;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31704 = D.31699->dreg;
      ins->sreg1 = D.31704;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.31707 = alloc_dreg (cfg, D.31706);
      D.31708 = (int) D.31707;
      ins->dreg = D.31708;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.31710>; else goto <D.31711>;
      <D.31710>:
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      D.31712 = mono_class_from_mono_type (D.31700);
      ins->klass = D.31712;
      <D.31711>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.31713>; else goto <D.31714>;
      <D.31713>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.31715>;
      <D.31714>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.31715>:
      sp.76 = sp;
      sp = sp.76 + 8;
      *sp.76 = ins;
      i = i + 1;
      <D.27845>:
      bblock.70 = bblock;
      D.31717 = bblock.70->in_scount;
      D.31718 = (int) D.31717;
      if (D.31718 > i) goto <D.27844>; else goto <D.27846>;
      <D.27846>:
      if (class_inits != 0B) goto <D.31719>; else goto <D.31720>;
      <D.31719>:
      monoeg_g_slist_free (class_inits);
      <D.31720>:
      class_inits = 0B;
      goto <D.31721>;
      <D.31655>:
      D.31071 = cfg->cil_offset_to_bb;
      ip.75 = (long int) ip;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31666 = ip.75 - D.31077;
      D.31667 = (long unsigned int) D.31666;
      D.31668 = D.31667 * 8;
      D.31669 = D.31071 + D.31668;
      tblock = *D.31669;
      if (tblock != 0B) goto <D.31722>; else goto <D.31723>;
      <D.31722>:
      bblock.70 = bblock;
      if (tblock != bblock.70) goto <D.31724>; else goto <D.31725>;
      <D.31724>:
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, tblock);
      if (sp != stack_start) goto <D.31726>; else goto <D.31727>;
      <D.31726>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31732 = (int) D.31731;
      handle_stack_args (cfg, stack_start, D.31732);
      sp = stack_start;
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31733 = D.31336 & 35184372088832;
      if (D.31733 != 0) goto <D.31734>; else goto <D.31735>;
      <D.31734>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31736>; else goto <D.31737>;
      <D.31736>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31738>; else goto <D.31739>;
      <D.31738>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31739>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31737>:
      D.31740 = mini_get_debug_options ();
      D.31741 = D.31740->break_on_unverified;
      if (D.31741 != 0) goto <D.31742>; else goto unverified;
      <D.31742>:
      raise (5);
      <D.31735>:
      <D.31727>:
      bblock.70 = bblock;
      bblock.70->next_bb = tblock;
      bblock = tblock;
      bblock.70 = bblock;
      cfg->cbb = bblock.70;
      i = 0;
      goto <D.27848>;
      <D.27847>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 3) goto <D.31743>; else goto <D.31744>;
      <D.31743>:
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31694 = (int) D.31693;
      printf ("loading %d from temp %d\n", i, D.31694);
      <D.31744>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      D.31745 = mono_type_to_regmove (cfg, D.31700);
      D.31746 = (short unsigned int) D.31745;
      ins->opcode = D.31746;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      type_to_eval_stack_type (cfg, D.31700, ins);
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31703 = D.31699->klass;
      ins->klass = D.31703;
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31704 = D.31699->dreg;
      ins->sreg1 = D.31704;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.31747 = alloc_dreg (cfg, D.31706);
      D.31748 = (int) D.31747;
      ins->dreg = D.31748;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.31749>; else goto <D.31750>;
      <D.31749>:
      D.31695 = cfg->varinfo;
      bblock.70 = bblock;
      D.31689 = bblock.70->in_stack;
      D.31069 = (long unsigned int) i;
      D.31690 = D.31069 * 8;
      D.31691 = D.31689 + D.31690;
      D.31692 = *D.31691;
      D.31693 = D.31692->data.op[0].const_val;
      D.31696 = (long unsigned int) D.31693;
      D.31697 = D.31696 * 8;
      D.31698 = D.31695 + D.31697;
      D.31699 = *D.31698;
      D.31700 = D.31699->data.op[1].vtype;
      D.31751 = mono_class_from_mono_type (D.31700);
      ins->klass = D.31751;
      <D.31750>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.31752>; else goto <D.31753>;
      <D.31752>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.31754>;
      <D.31753>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.31754>:
      sp.79 = sp;
      sp = sp.79 + 8;
      *sp.79 = ins;
      i = i + 1;
      <D.27848>:
      bblock.70 = bblock;
      D.31717 = bblock.70->in_scount;
      D.31718 = (int) D.31717;
      if (D.31718 > i) goto <D.27847>; else goto <D.27849>;
      <D.27849>:
      monoeg_g_slist_free (class_inits);
      class_inits = 0B;
      <D.31725>:
      <D.31723>:
      <D.31721>:
      if (skip_dead_blocks != 0) goto <D.31756>; else goto <D.31757>;
      <D.31756>:
      {
        int ip_offset;

        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        ip_offset = (int) D.31651;
        D.31758 = bb->end;
        if (D.31758 == ip_offset) goto <D.31759>; else goto <D.31760>;
        <D.31759>:
        bb = bb->next;
        <D.31760>:
        D.31761 = BIT_FIELD_REF <*bb, 64, 384>;
        D.31762 = D.31761 & 2;
        if (D.31762 != 0) goto <D.31763>; else goto <D.31764>;
        <D.31763>:
        {
          int op_size;

          op_size = mono_opcode_size (ip, end);
          D.31765 = op_size <= 0;
          D.31766 = (long int) D.31765;
          D.31767 = __builtin_expect (D.31766, 0);
          if (D.31767 != 0) goto <D.31768>; else goto <D.31769>;
          <D.31768>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7183, "op_size > 0");
          <D.31769>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 3) goto <D.31770>; else goto <D.31771>;
          <D.31770>:
          printf ("SKIPPING DEAD OP at %x\n", ip_offset);
          <D.31771>:
          D.31772 = ip_offset + op_size;
          D.31758 = bb->end;
          if (D.31772 == D.31758) goto <D.31773>; else goto <D.31774>;
          <D.31773>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 316;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          if (D.31279 != 0B) goto <D.31775>; else goto <D.31776>;
          <D.31775>:
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          D.31279->next = ins;
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          ins->prev = D.31279;
          bblock.70 = bblock;
          bblock.70->last_ins = ins;
          goto <D.31777>;
          <D.31776>:
          bblock.70 = bblock;
          bblock.70 = bblock;
          bblock.70->last_ins = ins;
          D.31279 = bblock.70->last_ins;
          bblock.70->code = D.31279;
          <D.31777>:
          start_new_bblock = 1;
          <D.31774>:
          D.31778 = (sizetype) op_size;
          ip = ip + D.31778;
          // predicted unlikely by continue predictor.
          goto <D.27852>;
        }
        <D.31764>:
      }
      <D.31757>:
      if (seq_points != 0) goto <D.31781>; else goto <D.31782>;
      <D.31781>:
      if (sp == stack_start) goto <D.31779>; else goto <D.31783>;
      <D.31783>:
      if (sym_seq_points != 0) goto <D.31784>; else goto <D.31780>;
      <D.31784>:
      ip.75 = (long int) ip;
      D.31088 = header->code;
      D.31650 = (long int) D.31088;
      D.31651 = ip.75 - D.31650;
      D.31785 = (long unsigned int) D.31651;
      D.31786 = D.31785 / 64;
      D.31787 = seq_point_locs->data[D.31786];
      ip.75 = (long int) ip;
      D.31088 = header->code;
      D.31650 = (long int) D.31088;
      D.31651 = ip.75 - D.31650;
      D.31788 = (int) D.31651;
      D.31789 = D.31788 & 63;
      D.31790 = D.31787 >> D.31789;
      D.31791 = D.31790 & 1;
      if (D.31791 != 0) goto <D.31779>; else goto <D.31780>;
      <D.31779>:
      {
        gboolean intr_loc;

        D.31088 = header->code;
        if (D.31088 == ip) goto <D.31793>; else goto <D.31796>;
        <D.31796>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 == 0B) goto <D.31797>; else goto <D.31794>;
        <D.31797>:
        D.31798 = cfg->header;
        D.31799 = BIT_FIELD_REF <*D.31798, 64, 64>;
        D.31800 = D.31799 & 9223090561878065152;
        if (D.31800 != 0) goto <D.31793>; else goto <D.31794>;
        <D.31793>:
        iftmp.80 = 1;
        goto <D.31795>;
        <D.31794>:
        iftmp.80 = 0;
        <D.31795>:
        intr_loc = iftmp.80;
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        ins->data.op[1].const_val = D.31651;
        D.31801 = intr_loc != 0;
        D.31802 = (unsigned char) D.31801;
        ins->flags = D.31802;
        if (sp != stack_start) goto <D.31803>; else goto <D.31804>;
        <D.31803>:
        D.31805 = ins->flags;
        D.31806 = D.31805 | 4;
        ins->flags = D.31806;
        <D.31804>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.31807>; else goto <D.31808>;
        <D.31807>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.31809>;
        <D.31808>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.31809>:
        if (sym_seq_points != 0) goto <D.31810>; else goto <D.31811>;
        <D.31810>:
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        D.31785 = (long unsigned int) D.31651;
        D.31812 = D.31785 / 64;
        D.31813 = seq_point_set_locs->data[D.31812];
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        D.31788 = (int) D.31651;
        D.31789 = D.31788 & 63;
        D.31814 = 1 << D.31789;
        D.31815 = D.31813 | D.31814;
        seq_point_set_locs->data[D.31812] = D.31815;
        <D.31811>:
      }
      <D.31780>:
      <D.31782>:
      bblock.70 = bblock;
      D.31108 = cfg->real_offset;
      bblock.70->real_offset = D.31108;
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.31816>; else goto <D.31817>;
      <D.31816>:
      D.31818 = cfg->coverage_info;
      if (D.31818 != 0B) goto <D.31819>; else goto <D.31820>;
      <D.31819>:
      {
        guint32 cil_offset;

        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        cil_offset = (guint32) D.31651;
        D.31818 = cfg->coverage_info;
        D.31818->data[cil_offset].cil_code = ip;
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31818 = cfg->coverage_info;
        D.31821 = &D.31818->data[cil_offset].count;
        ins->data.op[0].p = D.31821;
        ins->type = 3;
        D.31822 = alloc_dreg (cfg, 3);
        D.31823 = (int) D.31822;
        ins->dreg = D.31823;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.31824>; else goto <D.31825>;
        <D.31824>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.31826>;
        <D.31825>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.31826>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.31827 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31827;
          inst->prev = 0B;
          D.31828 = inst->prev;
          inst->next = D.31828;
          inst->opcode = 381;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31829 = inst->sreg3;
          inst->sreg2 = D.31829;
          D.31830 = inst->sreg2;
          inst->sreg1 = D.31830;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.31356 = ins->dreg;
          inst->dreg = D.31356;
          inst->data.op[0].const_val = 0;
          inst->data.op[1].const_val = 1;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.31831>; else goto <D.31832>;
          <D.31831>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.31833>;
          <D.31832>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.31833>:
        }
      }
      <D.31820>:
      <D.31817>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 3) goto <D.31834>; else goto <D.31835>;
      <D.31834>:
      bblock.70 = bblock;
      D.31836 = bblock.70->block_num;
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31732 = (int) D.31731;
      D.31837 = mono_disasm_code_one (0B, method, ip, 0B);
      printf ("converting (in B%d: stack: %d) %s", D.31836, D.31732, D.31837);
      <D.31835>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      switch (D.31839) <default: <D.28764>, case 0: <D.27856>, case 1: <D.27858>, case 2: <D.27859>, case 3: <D.27860>, case 4: <D.27861>, case 5: <D.27862>, case 6: <D.27863>, case 7: <D.27864>, case 8: <D.27865>, case 9: <D.27866>, case 10: <D.27867>, case 11: <D.27868>, case 12: <D.27869>, case 13: <D.27870>, case 14: <D.27871>, case 15: <D.27872>, case 16: <D.27875>, case 17: <D.27876>, case 18: <D.27877>, case 19: <D.27881>, case 20: <D.27882>, case 21: <D.27883>, case 22: <D.27884>, case 23: <D.27885>, case 24: <D.27886>, case 25: <D.27887>, case 26: <D.27888>, case 27: <D.27889>, case 28: <D.27890>, case 29: <D.27891>, case 30: <D.27892>, case 31: <D.27893>, case 32: <D.27894>, case 33: <D.27895>, case 34: <D.27896>, case 35: <D.27904>, case 37: <D.27912>, case 38: <D.27915>, case 39: <D.27916>, case 40: <D.27930>, case 41: <D.27929>, case 42: <D.28071>, case 43: <D.28077>, case 44: <D.28090>, case 45: <D.28091>, case 46: <D.28078>, case 47: <D.28079>, case 48: <D.28080>, case 49: <D.28081>, case 50: <D.28082>, case 51: <D.28083>, case 52: <D.28084>, case 53: <D.28085>, case 54: <D.28086>, case 55: <D.28087>, case 56: <D.28089>, case 57: <D.28092>, case 58: <D.28093>, case 59: <D.28098>, case 60: <D.28099>, case 61: <D.28100>, case 62: <D.28101>, case 63: <D.28102>, case 64: <D.28103>, case 65: <D.28104>, case 66: <D.28105>, case 67: <D.28106>, case 68: <D.28107>, case 69: <D.28109>, case 70: <D.28140>, case 71: <D.28141>, case 72: <D.28142>, case 73: <D.28143>, case 74: <D.28144>, case 75: <D.28145>, case 76: <D.28146>, case 77: <D.28147>, case 78: <D.28148>, case 79: <D.28149>, case 80: <D.28150>, case 81: <D.28157>, case 82: <D.28158>, case 83: <D.28159>, case 84: <D.28160>, case 85: <D.28161>, case 86: <D.28162>, case 87: <D.28163>, case 88: <D.28167>, case 89: <D.28168>, case 90: <D.28165>, case 91: <D.28169>, case 92: <D.28170>, case 93: <D.28171>, case 94: <D.28172>, case 95: <D.28173>, case 96: <D.28174>, case 97: <D.28175>, case 98: <D.28176>, case 99: <D.28177>, case 100: <D.28178>, case 101: <D.28182>, case 102: <D.28183>, case 103: <D.28184>, case 104: <D.28185>, case 105: <D.28186>, case 106: <D.28190>, case 107: <D.28187>, case 108: <D.28188>, case 109: <D.28189>, case 110: <D.28191>, case 111: <D.27931>, case 112: <D.28226>, case 113: <D.28230>, case 114: <D.28240>, case 115: <D.28251>, case 116: <D.28277>, case 117: <D.28287>, case 118: <D.28194>, case 119: <D.28762>, case 120: <D.28763>, case 121: <D.28322>, case 122: <D.28582>, case 123: <D.28326>, case 124: <D.28327>, case 125: <D.28328>, case 126: <D.28329>, case 127: <D.28330>, case 128: <D.28331>, case 129: <D.28444>, case 130: <D.28204>, case 131: <D.28205>, case 132: <D.28206>, case 133: <D.28207>, case 134: <D.28208>, case 135: <D.28209>, case 136: <D.28210>, case 137: <D.28211>, case 138: <D.28212>, case 139: <D.28213>, case 140: <D.28307>, case 141: <D.28445>, case 142: <D.28463>, case 143: <D.28464>, case 144: <D.28467>, case 145: <D.28468>, case 146: <D.28469>, case 147: <D.28470>, case 148: <D.28471>, case 149: <D.28472>, case 150: <D.28473>, case 151: <D.28474>, case 152: <D.28475>, case 153: <D.28476>, case 154: <D.28477>, case 155: <D.28507>, case 156: <D.28508>, case 157: <D.28509>, case 158: <D.28510>, case 159: <D.28511>, case 160: <D.28512>, case 161: <D.28513>, case 162: <D.28514>, case 163: <D.28466>, case 164: <D.28515>, case 165: <D.28297>, case 179: <D.28197>, case 180: <D.28201>, case 181: <D.28198>, case 182: <D.28202>, case 183: <D.28196>, case 184: <D.28203>, case 185: <D.28192>, case 186: <D.28193>, case 194: <D.28517>, case 195: <D.28516>, case 198: <D.28528>, case 208: <D.28549>, case 209: <D.28214>, case 210: <D.28215>, case 211: <D.28216>, case 212: <D.28199>, case 213: <D.28200>, case 214: <D.28218>, case 215: <D.28219>, case 216: <D.28220>, case 217: <D.28221>, case 218: <D.28222>, case 219: <D.28223>, case 220: <D.28583>, case 221: <D.28587>, case 222: <D.28588>, case 223: <D.28164>, case 224: <D.28217>, case 240: <D.28609>, case 254: <D.28680>>
      <D.27856>:
      if (seq_points != 0) goto <D.31840>; else goto <D.31841>;
      <D.31840>:
      if (sym_seq_points == 0) goto <D.31842>; else goto <D.31843>;
      <D.31842>:
      if (sp != stack_start) goto <D.31844>; else goto <D.31845>;
      <D.31844>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip.75 = (long int) ip;
      D.31088 = header->code;
      D.31650 = (long int) D.31088;
      D.31651 = ip.75 - D.31650;
      ins->data.op[1].const_val = D.31651;
      ins->flags = 0;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.31846>; else goto <D.31847>;
      <D.31846>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.31848>;
      <D.31847>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.31848>:
      <D.31845>:
      <D.31843>:
      <D.31841>:
      D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.31849 = D.30929 & 16;
      if (D.31849 != 0) goto <D.31850>; else goto <D.31851>;
      <D.31850>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 317;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      goto <D.31852>;
      <D.31851>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 316;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      <D.31852>:
      ip = ip + 1;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.31853>; else goto <D.31854>;
      <D.31853>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.31855>;
      <D.31854>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.31855>:
      goto <D.27857>;
      <D.27858>:
      D.30911 = cfg->method;
      D.31856 = should_insert_brekpoint (D.30911);
      if (D.31856 != 0) goto <D.31857>; else goto <D.31858>;
      <D.31857>:
      ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, 0B);
      goto <D.31859>;
      <D.31858>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 316;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      <D.31859>:
      ip = ip + 1;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.31860>; else goto <D.31861>;
      <D.31860>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.31862>;
      <D.31861>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.31862>:
      goto <D.27857>;
      <D.27859>:
      <D.27860>:
      <D.27861>:
      <D.27862>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.31864>; else goto <D.31865>;
      <D.31864>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31866>; else goto <D.31867>;
      <D.31866>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 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>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      n = D.31839 + -2;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.31874>; else goto <D.31875>;
      <D.31874>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31876>; else goto <D.31877>;
      <D.31876>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31878>; else goto <D.31879>;
      <D.31878>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31879>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31877>:
      D.31880 = mini_get_debug_options ();
      D.31881 = D.31880->break_on_unverified;
      if (D.31881 != 0) goto <D.31882>; else goto unverified;
      <D.31882>:
      raise (5);
      <D.31875>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.31887 = mono_type_to_regmove (cfg, D.31886);
      D.31888 = (short unsigned int) D.31887;
      ins->opcode = D.31888;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      type_to_eval_stack_type (cfg, D.31886, ins);
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31891 = D.31890->klass;
      ins->klass = D.31891;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31892 = D.31890->dreg;
      ins->sreg1 = D.31892;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.31893 = alloc_dreg (cfg, D.31706);
      D.31894 = (int) D.31893;
      ins->dreg = D.31894;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.31895>; else goto <D.31896>;
      <D.31895>:
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.31897 = mono_class_from_mono_type (D.31886);
      ins->klass = D.31897;
      <D.31896>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.31898>; else goto <D.31899>;
      <D.31898>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.31900>;
      <D.31899>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.31900>:
      ip = ip + 1;
      sp.82 = sp;
      sp = sp.82 + 8;
      *sp.82 = ins;
      goto <D.27857>;
      <D.27863>:
      <D.27864>:
      <D.27865>:
      <D.27866>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.31902>; else goto <D.31903>;
      <D.31902>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31904>; else goto <D.31905>;
      <D.31904>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31906>; else goto <D.31907>;
      <D.31906>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31907>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31905>:
      D.31908 = mini_get_debug_options ();
      D.31909 = D.31908->break_on_unverified;
      if (D.31909 != 0) goto <D.31910>; else goto unverified;
      <D.31910>:
      raise (5);
      <D.31903>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      n = D.31839 + -6;
      n.81 = (unsigned int) n;
      D.31546 = header->num_locals;
      D.31911 = (unsigned int) D.31546;
      if (n.81 >= D.31911) goto <D.31912>; else goto <D.31913>;
      <D.31912>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31914>; else goto <D.31915>;
      <D.31914>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31916>; else goto <D.31917>;
      <D.31916>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31917>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31915>:
      D.31918 = mini_get_debug_options ();
      D.31919 = D.31918->break_on_unverified;
      if (D.31919 != 0) goto <D.31920>; else goto unverified;
      <D.31920>:
      raise (5);
      <D.31913>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31534 = header->locals[n];
      D.31921 = mono_type_to_regmove (cfg, D.31534);
      D.31922 = (short unsigned int) D.31921;
      ins->opcode = D.31922;
      D.31534 = header->locals[n];
      type_to_eval_stack_type (cfg, D.31534, ins);
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31926 = D.31925->klass;
      ins->klass = D.31926;
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31927 = D.31925->dreg;
      ins->sreg1 = D.31927;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.31928 = alloc_dreg (cfg, D.31706);
      D.31929 = (int) D.31928;
      ins->dreg = D.31929;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.31930>; else goto <D.31931>;
      <D.31930>:
      D.31534 = header->locals[n];
      D.31932 = mono_class_from_mono_type (D.31534);
      ins->klass = D.31932;
      <D.31931>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.31933>; else goto <D.31934>;
      <D.31933>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.31935>;
      <D.31934>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.31935>:
      ip = ip + 1;
      sp.83 = sp;
      sp = sp.83 + 8;
      *sp.83 = ins;
      goto <D.27857>;
      <D.27867>:
      <D.27868>:
      <D.27869>:
      <D.27870>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.31937>; else goto <D.31938>;
      <D.31937>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31939>; else goto <D.31940>;
      <D.31939>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31941>; else goto <D.31942>;
      <D.31941>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31942>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31940>:
      D.31943 = mini_get_debug_options ();
      D.31944 = D.31943->break_on_unverified;
      if (D.31944 != 0) goto <D.31945>; else goto unverified;
      <D.31945>:
      raise (5);
      <D.31938>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      n = D.31839 + -10;
      n.81 = (unsigned int) n;
      D.31546 = header->num_locals;
      D.31911 = (unsigned int) D.31546;
      if (n.81 >= D.31911) goto <D.31946>; else goto <D.31947>;
      <D.31946>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31948>; else goto <D.31949>;
      <D.31948>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31950>; else goto <D.31951>;
      <D.31950>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31951>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31949>:
      D.31952 = mini_get_debug_options ();
      D.31953 = D.31952->break_on_unverified;
      if (D.31953 != 0) goto <D.31954>; else goto unverified;
      <D.31954>:
      raise (5);
      <D.31947>:
      sp = sp + 18446744073709551608;
      if (dont_verify_stloc == 0) goto <D.31955>; else goto <D.31956>;
      <D.31955>:
      D.31534 = header->locals[n];
      D.31957 = *sp;
      D.31958 = target_type_is_incompatible (cfg, D.31534, D.31957);
      if (D.31958 != 0) goto <D.31959>; else goto <D.31960>;
      <D.31959>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31961>; else goto <D.31962>;
      <D.31961>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31963>; else goto <D.31964>;
      <D.31963>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31964>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31962>:
      D.31965 = mini_get_debug_options ();
      D.31966 = D.31965->break_on_unverified;
      if (D.31966 != 0) goto <D.31967>; else goto unverified;
      <D.31967>:
      raise (5);
      <D.31960>:
      <D.31956>:
      emit_stloc_ir (cfg, sp, header, n);
      ip = ip + 1;
      inline_costs = inline_costs + 1;
      goto <D.27857>;
      <D.27871>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.31969>; else goto <D.31970>;
      <D.31969>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31971>; else goto <D.31972>;
      <D.31971>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31973>; else goto <D.31974>;
      <D.31973>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31974>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31972>:
      D.31975 = mini_get_debug_options ();
      D.31976 = D.31975->break_on_unverified;
      if (D.31976 != 0) goto <D.31977>; else goto unverified;
      <D.31977>:
      raise (5);
      <D.31970>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.31978>; else goto <D.31979>;
      <D.31978>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31980>; else goto <D.31981>;
      <D.31980>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31982>; else goto <D.31983>;
      <D.31982>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31983>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31981>:
      D.31984 = mini_get_debug_options ();
      D.31985 = D.31984->break_on_unverified;
      if (D.31985 != 0) goto <D.31986>; else goto unverified;
      <D.31986>:
      raise (5);
      <D.31979>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      n = (int) D.31988;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.31989>; else goto <D.31990>;
      <D.31989>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.31991>; else goto <D.31992>;
      <D.31991>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.31993>; else goto <D.31994>;
      <D.31993>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31994>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31992>:
      D.31995 = mini_get_debug_options ();
      D.31996 = D.31995->break_on_unverified;
      if (D.31996 != 0) goto <D.31997>; else goto unverified;
      <D.31997>:
      raise (5);
      <D.31990>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.31998 = mono_type_to_regmove (cfg, D.31886);
      D.31999 = (short unsigned int) D.31998;
      ins->opcode = D.31999;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      type_to_eval_stack_type (cfg, D.31886, ins);
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31891 = D.31890->klass;
      ins->klass = D.31891;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31892 = D.31890->dreg;
      ins->sreg1 = D.31892;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.32000 = alloc_dreg (cfg, D.31706);
      D.32001 = (int) D.32000;
      ins->dreg = D.32001;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.32002>; else goto <D.32003>;
      <D.32002>:
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.32004 = mono_class_from_mono_type (D.31886);
      ins->klass = D.32004;
      <D.32003>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32005>; else goto <D.32006>;
      <D.32005>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32007>;
      <D.32006>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32007>:
      sp.84 = sp;
      sp = sp.84 + 8;
      *sp.84 = ins;
      ip = ip + 2;
      goto <D.27857>;
      <D.27872>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.32009>; else goto <D.32010>;
      <D.32009>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32011>; else goto <D.32012>;
      <D.32011>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32014>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32012>:
      D.32015 = mini_get_debug_options ();
      D.32016 = D.32015->break_on_unverified;
      if (D.32016 != 0) goto <D.32017>; else goto unverified;
      <D.32017>:
      raise (5);
      <D.32010>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32018>; else goto <D.32019>;
      <D.32018>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32020>; else goto <D.32021>;
      <D.32020>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32022>; else goto <D.32023>;
      <D.32022>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32023>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32021>:
      D.32024 = mini_get_debug_options ();
      D.32025 = D.32024->break_on_unverified;
      if (D.32025 != 0) goto <D.32026>; else goto unverified;
      <D.32026>:
      raise (5);
      <D.32019>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      n = (int) D.31988;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32029>; else goto <D.32030>;
      <D.32029>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32031>; else goto <D.32032>;
      <D.32031>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32032>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32030>:
      D.32033 = mini_get_debug_options ();
      D.32034 = D.32033->break_on_unverified;
      if (D.32034 != 0) goto <D.32035>; else goto unverified;
      <D.32035>:
      raise (5);
      <D.32028>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      ins->data.op[0].p = D.32037;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32038 = D.32037->flags;
      D.32039 = D.32038 | 16;
      D.32037->flags = D.32039;
      ins->type = 5;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32040 = D.32037->klass;
      ins->klass = D.32040;
      D.32041 = alloc_dreg (cfg, 5);
      D.32042 = (int) D.32041;
      ins->dreg = D.32042;
      cfg->has_indirection = 1;
      D.31089 = cfg->gsharedvt;
      D.32043 = D.31089 != 0;
      D.32044 = (long int) D.32043;
      D.32045 = __builtin_expect (D.32044, 0);
      if (D.32045 != 0) goto <D.32046>; else goto <D.32047>;
      <D.32046>:
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32048 = D.32037->data.op[1].vtype;
      D.32049 = mini_is_gsharedvt_variable_type (cfg, D.32048);
      if (D.32049 != 0) goto <D.32050>; else goto <D.32051>;
      <D.32050>:
      handle_gsharedvt_ldaddr (cfg);
      <D.32051>:
      <D.32047>:
      if (0 != 0) goto <D.32052>; else goto <D.32053>;
      <D.32052>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32056 = D.32055 + 1;
        D.32057 = (unsigned int) D.32056;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.32057 < D.32058) goto <D.32059>; else goto <D.32060>;
        <D.32059>:
        D.32061 = cfg->vreg_to_inst;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32062 = (sizetype) D.32055;
        D.32063 = D.32062 + 1;
        D.32064 = D.32063 * 8;
        D.32065 = D.32061 + D.32064;
        iftmp.85 = *D.32065;
        goto <D.32066>;
        <D.32060>:
        iftmp.85 = 0B;
        <D.32066>:
        var1 = iftmp.85;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32068 = D.32055 + 2;
        D.32069 = (unsigned int) D.32068;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.32069 < D.32058) goto <D.32070>; else goto <D.32071>;
        <D.32070>:
        D.32061 = cfg->vreg_to_inst;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32062 = (sizetype) D.32055;
        D.32072 = D.32062 + 2;
        D.32073 = D.32072 * 8;
        D.32074 = D.32061 + D.32073;
        iftmp.86 = *D.32074;
        goto <D.32075>;
        <D.32071>:
        iftmp.86 = 0B;
        <D.32075>:
        var2 = iftmp.86;
        D.32076 = var1 == 0B;
        D.32077 = (long int) D.32076;
        D.32078 = __builtin_expect (D.32077, 0);
        if (D.32078 != 0) goto <D.32079>; else goto <D.32080>;
        <D.32079>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7323, "var1");
        <D.32080>:
        D.32081 = var2 == 0B;
        D.32082 = (long int) D.32081;
        D.32083 = __builtin_expect (D.32082, 0);
        if (D.32083 != 0) goto <D.32084>; else goto <D.32085>;
        <D.32084>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7323, "var2");
        <D.32085>:
        D.32086 = var1->flags;
        D.32087 = D.32086 | 16;
        var1->flags = D.32087;
        D.32088 = var2->flags;
        D.32089 = D.32088 | 16;
        var2->flags = D.32089;
      }
      <D.32053>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32090>; else goto <D.32091>;
      <D.32090>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32092>;
      <D.32091>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32092>:
      sp.87 = sp;
      sp = sp.87 + 8;
      *sp.87 = ins;
      ip = ip + 2;
      goto <D.27857>;
      <D.27875>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.32094>; else goto <D.32095>;
      <D.32094>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32096>; else goto <D.32097>;
      <D.32096>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32098>; else goto <D.32099>;
      <D.32098>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32099>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32097>:
      D.32100 = mini_get_debug_options ();
      D.32101 = D.32100->break_on_unverified;
      if (D.32101 != 0) goto <D.32102>; else goto unverified;
      <D.32102>:
      raise (5);
      <D.32095>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.32103>; else goto <D.32104>;
      <D.32103>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32105>; else goto <D.32106>;
      <D.32105>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32107>; else goto <D.32108>;
      <D.32107>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32108>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32106>:
      D.32109 = mini_get_debug_options ();
      D.32110 = D.32109->break_on_unverified;
      if (D.32110 != 0) goto <D.32111>; else goto unverified;
      <D.32111>:
      raise (5);
      <D.32104>:
      sp = sp + 18446744073709551608;
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      n = (int) D.31988;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.32112>; else goto <D.32113>;
      <D.32112>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32114>; else goto <D.32115>;
      <D.32114>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32116>; else goto <D.32117>;
      <D.32116>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32117>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32115>:
      D.32118 = mini_get_debug_options ();
      D.32119 = D.32118->break_on_unverified;
      if (D.32119 != 0) goto <D.32120>; else goto unverified;
      <D.32120>:
      raise (5);
      <D.32113>:
      if (dont_verify_stloc == 0) goto <D.32121>; else goto <D.32122>;
      <D.32121>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32123 = (long unsigned int) D.31988;
      D.32124 = D.32123 * 8;
      D.32125 = param_types + D.32124;
      D.32126 = *D.32125;
      D.31957 = *sp;
      D.32127 = target_type_is_incompatible (cfg, D.32126, D.31957);
      if (D.32127 != 0) goto <D.32128>; else goto <D.32129>;
      <D.32128>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32130>; else goto <D.32131>;
      <D.32130>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32132>; else goto <D.32133>;
      <D.32132>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32133>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32131>:
      D.32134 = mini_get_debug_options ();
      D.32135 = D.32134->break_on_unverified;
      if (D.32135 != 0) goto <D.32136>; else goto unverified;
      <D.32136>:
      raise (5);
      <D.32129>:
      <D.32122>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.32137 = mono_type_to_regmove (cfg, D.31886);
      D.32138 = (short unsigned int) D.32137;
      ins->opcode = D.32138;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31891 = D.31890->klass;
      ins->klass = D.31891;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31892 = D.31890->dreg;
      ins->dreg = D.31892;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.32140>; else goto <D.32141>;
      <D.32140>:
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.32142 = mono_class_from_mono_type (D.31886);
      ins->klass = D.32142;
      <D.32141>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32143>; else goto <D.32144>;
      <D.32143>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32145>;
      <D.32144>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32145>:
      ip = ip + 2;
      goto <D.27857>;
      <D.27876>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.32146>; else goto <D.32147>;
      <D.32146>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32148>; else goto <D.32149>;
      <D.32148>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32150>; else goto <D.32151>;
      <D.32150>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32151>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32149>:
      D.32152 = mini_get_debug_options ();
      D.32153 = D.32152->break_on_unverified;
      if (D.32153 != 0) goto <D.32154>; else goto unverified;
      <D.32154>:
      raise (5);
      <D.32147>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32155>; else goto <D.32156>;
      <D.32155>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32157>; else goto <D.32158>;
      <D.32157>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32159>; else goto <D.32160>;
      <D.32159>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32160>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32158>:
      D.32161 = mini_get_debug_options ();
      D.32162 = D.32161->break_on_unverified;
      if (D.32162 != 0) goto <D.32163>; else goto unverified;
      <D.32163>:
      raise (5);
      <D.32156>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      n = (int) D.31988;
      n.81 = (unsigned int) n;
      D.31546 = header->num_locals;
      D.31911 = (unsigned int) D.31546;
      if (n.81 >= D.31911) goto <D.32164>; else goto <D.32165>;
      <D.32164>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32166>; else goto <D.32167>;
      <D.32166>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32168>; else goto <D.32169>;
      <D.32168>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32169>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32167>:
      D.32170 = mini_get_debug_options ();
      D.32171 = D.32170->break_on_unverified;
      if (D.32171 != 0) goto <D.32172>; else goto unverified;
      <D.32172>:
      raise (5);
      <D.32165>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31534 = header->locals[n];
      D.32173 = mono_type_to_regmove (cfg, D.31534);
      D.32174 = (short unsigned int) D.32173;
      ins->opcode = D.32174;
      D.31534 = header->locals[n];
      type_to_eval_stack_type (cfg, D.31534, ins);
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31926 = D.31925->klass;
      ins->klass = D.31926;
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31927 = D.31925->dreg;
      ins->sreg1 = D.31927;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.32175 = alloc_dreg (cfg, D.31706);
      D.32176 = (int) D.32175;
      ins->dreg = D.32176;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.32177>; else goto <D.32178>;
      <D.32177>:
      D.31534 = header->locals[n];
      D.32179 = mono_class_from_mono_type (D.31534);
      ins->klass = D.32179;
      <D.32178>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32180>; else goto <D.32181>;
      <D.32180>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32182>;
      <D.32181>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32182>:
      sp.88 = sp;
      sp = sp.88 + 8;
      *sp.88 = ins;
      ip = ip + 2;
      goto <D.27857>;
      <D.27877>:
      {
        unsigned char * tmp_ip;

        D.31968 = ip + 2;
        if (D.31968 > end) goto <D.32184>; else goto <D.32185>;
        <D.32184>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32186>; else goto <D.32187>;
        <D.32186>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32188>; else goto <D.32189>;
        <D.32188>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32189>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32187>:
        D.32190 = mini_get_debug_options ();
        D.32191 = D.32190->break_on_unverified;
        if (D.32191 != 0) goto <D.32192>; else goto unverified;
        <D.32192>:
        raise (5);
        <D.32185>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.32193>; else goto <D.32194>;
        <D.32193>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32195>; else goto <D.32196>;
        <D.32195>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32197>; else goto <D.32198>;
        <D.32197>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32198>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32196>:
        D.32199 = mini_get_debug_options ();
        D.32200 = D.32199->break_on_unverified;
        if (D.32200 != 0) goto <D.32201>; else goto unverified;
        <D.32201>:
        raise (5);
        <D.32194>:
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32202 = (short unsigned int) D.31988;
        D.31546 = header->num_locals;
        if (D.32202 >= D.31546) goto <D.32203>; else goto <D.32204>;
        <D.32203>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32205>; else goto <D.32206>;
        <D.32205>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32207>; else goto <D.32208>;
        <D.32207>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32208>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32206>:
        D.32209 = mini_get_debug_options ();
        D.32210 = D.32209->break_on_unverified;
        if (D.32210 != 0) goto <D.32211>; else goto unverified;
        <D.32211>:
        raise (5);
        <D.32204>:
        tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 1);
        if (tmp_ip != 0B) goto <D.32212>; else goto <D.32213>;
        <D.32212>:
        ip = tmp_ip;
        inline_costs = inline_costs + 1;
        goto <D.27857>;
        <D.32213>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31923 = cfg->locals;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32123 = (long unsigned int) D.31988;
        D.32124 = D.32123 * 8;
        D.32214 = D.31923 + D.32124;
        D.32215 = *D.32214;
        ins->data.op[0].p = D.32215;
        D.31923 = cfg->locals;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32123 = (long unsigned int) D.31988;
        D.32124 = D.32123 * 8;
        D.32214 = D.31923 + D.32124;
        D.32215 = *D.32214;
        D.31923 = cfg->locals;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32123 = (long unsigned int) D.31988;
        D.32124 = D.32123 * 8;
        D.32214 = D.31923 + D.32124;
        D.32215 = *D.32214;
        D.32216 = D.32215->flags;
        D.32217 = D.32216 | 16;
        D.32215->flags = D.32217;
        ins->type = 5;
        D.31923 = cfg->locals;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32123 = (long unsigned int) D.31988;
        D.32124 = D.32123 * 8;
        D.32214 = D.31923 + D.32124;
        D.32215 = *D.32214;
        D.32218 = D.32215->klass;
        ins->klass = D.32218;
        D.32219 = alloc_dreg (cfg, 5);
        D.32220 = (int) D.32219;
        ins->dreg = D.32220;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.32221>; else goto <D.32222>;
        <D.32221>:
        D.31923 = cfg->locals;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.32123 = (long unsigned int) D.31988;
        D.32124 = D.32123 * 8;
        D.32214 = D.31923 + D.32124;
        D.32215 = *D.32214;
        D.32223 = D.32215->data.op[1].vtype;
        D.32224 = mini_is_gsharedvt_variable_type (cfg, D.32223);
        if (D.32224 != 0) goto <D.32225>; else goto <D.32226>;
        <D.32225>:
        handle_gsharedvt_ldaddr (cfg);
        <D.32226>:
        <D.32222>:
        if (0 != 0) goto <D.32227>; else goto <D.32228>;
        <D.32227>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31923 = cfg->locals;
          D.31987 = ip + 1;
          D.31988 = *D.31987;
          D.32123 = (long unsigned int) D.31988;
          D.32124 = D.32123 * 8;
          D.32214 = D.31923 + D.32124;
          D.32215 = *D.32214;
          D.32230 = D.32215->dreg;
          D.32231 = D.32230 + 1;
          D.32232 = (unsigned int) D.32231;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.32232 < D.32058) goto <D.32233>; else goto <D.32234>;
          <D.32233>:
          D.32061 = cfg->vreg_to_inst;
          D.31923 = cfg->locals;
          D.31987 = ip + 1;
          D.31988 = *D.31987;
          D.32123 = (long unsigned int) D.31988;
          D.32124 = D.32123 * 8;
          D.32214 = D.31923 + D.32124;
          D.32215 = *D.32214;
          D.32230 = D.32215->dreg;
          D.32235 = (sizetype) D.32230;
          D.32236 = D.32235 + 1;
          D.32237 = D.32236 * 8;
          D.32238 = D.32061 + D.32237;
          iftmp.89 = *D.32238;
          goto <D.32239>;
          <D.32234>:
          iftmp.89 = 0B;
          <D.32239>:
          var1 = iftmp.89;
          D.31923 = cfg->locals;
          D.31987 = ip + 1;
          D.31988 = *D.31987;
          D.32123 = (long unsigned int) D.31988;
          D.32124 = D.32123 * 8;
          D.32214 = D.31923 + D.32124;
          D.32215 = *D.32214;
          D.32230 = D.32215->dreg;
          D.32241 = D.32230 + 2;
          D.32242 = (unsigned int) D.32241;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.32242 < D.32058) goto <D.32243>; else goto <D.32244>;
          <D.32243>:
          D.32061 = cfg->vreg_to_inst;
          D.31923 = cfg->locals;
          D.31987 = ip + 1;
          D.31988 = *D.31987;
          D.32123 = (long unsigned int) D.31988;
          D.32124 = D.32123 * 8;
          D.32214 = D.31923 + D.32124;
          D.32215 = *D.32214;
          D.32230 = D.32215->dreg;
          D.32235 = (sizetype) D.32230;
          D.32245 = D.32235 + 2;
          D.32246 = D.32245 * 8;
          D.32247 = D.32061 + D.32246;
          iftmp.90 = *D.32247;
          goto <D.32248>;
          <D.32244>:
          iftmp.90 = 0B;
          <D.32248>:
          var2 = iftmp.90;
          D.32249 = var1 == 0B;
          D.32250 = (long int) D.32249;
          D.32251 = __builtin_expect (D.32250, 0);
          if (D.32251 != 0) goto <D.32252>; else goto <D.32253>;
          <D.32252>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7360, "var1");
          <D.32253>:
          D.32254 = var2 == 0B;
          D.32255 = (long int) D.32254;
          D.32256 = __builtin_expect (D.32255, 0);
          if (D.32256 != 0) goto <D.32257>; else goto <D.32258>;
          <D.32257>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7360, "var2");
          <D.32258>:
          D.32259 = var1->flags;
          D.32260 = D.32259 | 16;
          var1->flags = D.32260;
          D.32261 = var2->flags;
          D.32262 = D.32261 | 16;
          var2->flags = D.32262;
        }
        <D.32228>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.32263>; else goto <D.32264>;
        <D.32263>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.32265>;
        <D.32264>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.32265>:
        sp.91 = sp;
        sp = sp.91 + 8;
        *sp.91 = ins;
        ip = ip + 2;
        goto <D.27857>;
      }
      <D.27881>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.32267>; else goto <D.32268>;
      <D.32267>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32269>; else goto <D.32270>;
      <D.32269>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32271>; else goto <D.32272>;
      <D.32271>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32272>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32270>:
      D.32273 = mini_get_debug_options ();
      D.32274 = D.32273->break_on_unverified;
      if (D.32274 != 0) goto <D.32275>; else goto unverified;
      <D.32275>:
      raise (5);
      <D.32268>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.32276>; else goto <D.32277>;
      <D.32276>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32278>; else goto <D.32279>;
      <D.32278>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 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>:
      sp = sp + 18446744073709551608;
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32202 = (short unsigned int) D.31988;
      D.31546 = header->num_locals;
      if (D.32202 >= D.31546) goto <D.32285>; else goto <D.32286>;
      <D.32285>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32287>; else goto <D.32288>;
      <D.32287>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32289>; else goto <D.32290>;
      <D.32289>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32290>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32288>:
      D.32291 = mini_get_debug_options ();
      D.32292 = D.32291->break_on_unverified;
      if (D.32292 != 0) goto <D.32293>; else goto unverified;
      <D.32293>:
      raise (5);
      <D.32286>:
      if (dont_verify_stloc == 0) goto <D.32294>; else goto <D.32295>;
      <D.32294>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      D.32297 = header->locals[D.32296];
      D.31957 = *sp;
      D.32298 = target_type_is_incompatible (cfg, D.32297, D.31957);
      if (D.32298 != 0) goto <D.32299>; else goto <D.32300>;
      <D.32299>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32301>; else goto <D.32302>;
      <D.32301>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32303>; else goto <D.32304>;
      <D.32303>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32304>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32302>:
      D.32305 = mini_get_debug_options ();
      D.32306 = D.32305->break_on_unverified;
      if (D.32306 != 0) goto <D.32307>; else goto unverified;
      <D.32307>:
      raise (5);
      <D.32300>:
      <D.32295>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      emit_stloc_ir (cfg, sp, header, D.32296);
      ip = ip + 2;
      inline_costs = inline_costs + 1;
      goto <D.27857>;
      <D.27882>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32308>; else goto <D.32309>;
      <D.32308>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32310>; else goto <D.32311>;
      <D.32310>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32312>; else goto <D.32313>;
      <D.32312>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32313>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32311>:
      D.32314 = mini_get_debug_options ();
      D.32315 = D.32314->break_on_unverified;
      if (D.32315 != 0) goto <D.32316>; else goto unverified;
      <D.32316>:
      raise (5);
      <D.32309>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[0].p = 0B;
      ins->type = 3;
      D.32317 = alloc_dreg (cfg, 3);
      D.32318 = (int) D.32317;
      ins->dreg = D.32318;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32319>; else goto <D.32320>;
      <D.32319>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32321>;
      <D.32320>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32321>:
      ins->type = 6;
      ip = ip + 1;
      sp.92 = sp;
      sp = sp.92 + 8;
      *sp.92 = ins;
      goto <D.27857>;
      <D.27883>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32323>; else goto <D.32324>;
      <D.32323>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32325>; else goto <D.32326>;
      <D.32325>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32327>; else goto <D.32328>;
      <D.32327>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32328>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32326>:
      D.32329 = mini_get_debug_options ();
      D.32330 = D.32329->break_on_unverified;
      if (D.32330 != 0) goto <D.32331>; else goto unverified;
      <D.32331>:
      raise (5);
      <D.32324>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[0].const_val = -1;
      ins->type = 1;
      D.32332 = alloc_dreg (cfg, 1);
      D.32333 = (int) D.32332;
      ins->dreg = D.32333;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32334>; else goto <D.32335>;
      <D.32334>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32336>;
      <D.32335>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32336>:
      ip = ip + 1;
      sp.93 = sp;
      sp = sp.93 + 8;
      *sp.93 = ins;
      goto <D.27857>;
      <D.27884>:
      <D.27885>:
      <D.27886>:
      <D.27887>:
      <D.27888>:
      <D.27889>:
      <D.27890>:
      <D.27891>:
      <D.27892>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32338>; else goto <D.32339>;
      <D.32338>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32340>; else goto <D.32341>;
      <D.32340>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32342>; else goto <D.32343>;
      <D.32342>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32343>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32341>:
      D.32344 = mini_get_debug_options ();
      D.32345 = D.32344->break_on_unverified;
      if (D.32345 != 0) goto <D.32346>; else goto unverified;
      <D.32346>:
      raise (5);
      <D.32339>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      D.32347 = D.31839 + -22;
      D.32348 = (long int) D.32347;
      ins->data.op[0].const_val = D.32348;
      ins->type = 1;
      D.32349 = alloc_dreg (cfg, 1);
      D.32350 = (int) D.32349;
      ins->dreg = D.32350;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32351>; else goto <D.32352>;
      <D.32351>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32353>;
      <D.32352>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32353>:
      ip = ip + 1;
      sp.94 = sp;
      sp = sp.94 + 8;
      *sp.94 = ins;
      goto <D.27857>;
      <D.27893>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.32355>; else goto <D.32356>;
      <D.32355>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32357>; else goto <D.32358>;
      <D.32357>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32359>; else goto <D.32360>;
      <D.32359>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32360>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32358>:
      D.32361 = mini_get_debug_options ();
      D.32362 = D.32361->break_on_unverified;
      if (D.32362 != 0) goto <D.32363>; else goto unverified;
      <D.32363>:
      raise (5);
      <D.32356>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32364>; else goto <D.32365>;
      <D.32364>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32366>; else goto <D.32367>;
      <D.32366>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32368>; else goto <D.32369>;
      <D.32368>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32369>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32367>:
      D.32370 = mini_get_debug_options ();
      D.32371 = D.32370->break_on_unverified;
      if (D.32371 != 0) goto <D.32372>; else goto unverified;
      <D.32372>:
      raise (5);
      <D.32365>:
      ip = ip + 1;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.32373 = MEM[(signed char *)ip];
      D.32374 = (long int) D.32373;
      ins->data.op[0].const_val = D.32374;
      ins->type = 1;
      D.32375 = alloc_dreg (cfg, 1);
      D.32376 = (int) D.32375;
      ins->dreg = D.32376;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32377>; else goto <D.32378>;
      <D.32377>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32379>;
      <D.32378>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32379>:
      ip = ip + 1;
      sp.95 = sp;
      sp = sp.95 + 8;
      *sp.95 = ins;
      goto <D.27857>;
      <D.27894>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.32382>; else goto <D.32383>;
      <D.32382>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32384>; else goto <D.32385>;
      <D.32384>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32386>; else goto <D.32387>;
      <D.32386>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32387>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32385>:
      D.32388 = mini_get_debug_options ();
      D.32389 = D.32388->break_on_unverified;
      if (D.32389 != 0) goto <D.32390>; else goto unverified;
      <D.32390>:
      raise (5);
      <D.32383>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32391>; else goto <D.32392>;
      <D.32391>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32393>; else goto <D.32394>;
      <D.32393>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32395>; else goto <D.32396>;
      <D.32395>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32396>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32394>:
      D.32397 = mini_get_debug_options ();
      D.32398 = D.32397->break_on_unverified;
      if (D.32398 != 0) goto <D.32399>; else goto unverified;
      <D.32399>:
      raise (5);
      <D.32392>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.32400 = ip + 1;
      D.32401 = *D.32400;
      D.32402 = (int) D.32401;
      D.32403 = (long int) D.32402;
      ins->data.op[0].const_val = D.32403;
      ins->type = 1;
      D.32404 = alloc_dreg (cfg, 1);
      D.32405 = (int) D.32404;
      ins->dreg = D.32405;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.32406>; else goto <D.32407>;
      <D.32406>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.32408>;
      <D.32407>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.32408>:
      ip = ip + 5;
      sp.96 = sp;
      sp = sp.96 + 8;
      *sp.96 = ins;
      goto <D.27857>;
      <D.27895>:
      D.32410 = ip + 9;
      if (D.32410 > end) goto <D.32411>; else goto <D.32412>;
      <D.32411>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32413>; else goto <D.32414>;
      <D.32413>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32415>; else goto <D.32416>;
      <D.32415>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32416>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32414>:
      D.32417 = mini_get_debug_options ();
      D.32418 = D.32417->break_on_unverified;
      if (D.32418 != 0) goto <D.32419>; else goto unverified;
      <D.32419>:
      raise (5);
      <D.32412>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.32420>; else goto <D.32421>;
      <D.32420>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32422>; else goto <D.32423>;
      <D.32422>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32424>; else goto <D.32425>;
      <D.32424>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32425>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32423>:
      D.32426 = mini_get_debug_options ();
      D.32427 = D.32426->break_on_unverified;
      if (D.32427 != 0) goto <D.32428>; else goto unverified;
      <D.32428>:
      raise (5);
      <D.32421>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->type = 2;
      D.32429 = alloc_dreg (cfg, 2);
      D.32430 = (int) D.32429;
      ins->dreg = D.32430;
      ip = ip + 1;
      D.32431 = MEM[(const guint64 *)ip];
      D.32432 = (long int) D.32431;
      ins->data.i8const = D.32432;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.32433>; else goto <D.32434>;
      <D.32433>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.32435>;
      <D.32434>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.32435>:
      ip = ip + 8;
      sp.97 = sp;
      sp = sp.97 + 8;
      *sp.97 = ins;
      goto <D.27857>;
      <D.27896>:
      {
        float * f;
        gboolean use_aotconst;

        use_aotconst = 0;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.32437>; else goto <D.32438>;
        <D.32437>:
        use_aotconst = 1;
        <D.32438>:
        D.30966 = cfg->domain;
        f = mono_domain_alloc (D.30966, 4);
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.32439>; else goto <D.32440>;
        <D.32439>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32441>; else goto <D.32442>;
        <D.32441>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32443>; else goto <D.32444>;
        <D.32443>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32444>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32442>:
        D.32445 = mini_get_debug_options ();
        D.32446 = D.32445->break_on_unverified;
        if (D.32446 != 0) goto <D.32447>; else goto unverified;
        <D.32447>:
        raise (5);
        <D.32440>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.32448>; else goto <D.32449>;
        <D.32448>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32450>; else goto <D.32451>;
        <D.32450>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32452>; else goto <D.32453>;
        <D.32452>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32453>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32451>:
        D.32454 = mini_get_debug_options ();
        D.32455 = D.32454->break_on_unverified;
        if (D.32455 != 0) goto <D.32456>; else goto unverified;
        <D.32456>:
        raise (5);
        <D.32449>:
        if (use_aotconst != 0) goto <D.32457>; else goto <D.32458>;
        <D.32457>:
        {
          struct MonoInst * cons;
          int dreg;

          D.30941 = cfg->mempool;
          cons = mono_mempool_alloc (D.30941, 80);
          cons->data.op[1].const_val = 0;
          D.32459 = cons->data.op[1].const_val;
          cons->data.op[0].const_val = D.32459;
          cons->prev = 0B;
          D.32460 = cons->prev;
          cons->next = D.32460;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.32462>; else goto <D.32463>;
          <D.32462>:
          iftmp.98 = 734;
          goto <D.32464>;
          <D.32463>:
          iftmp.98 = 363;
          <D.32464>:
          cons->opcode = iftmp.98;
          cons->flags = 0;
          cons->type = 0;
          cons->dreg = -1;
          cons->sreg3 = -1;
          D.32465 = cons->sreg3;
          cons->sreg2 = D.32465;
          D.32466 = cons->sreg2;
          cons->sreg1 = D.32466;
          D.31162 = cfg->ip;
          cons->cil_code = D.31162;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.32467>; else goto <D.32468>;
          <D.32467>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.30941 = cfg->mempool;
            group = mono_mempool_alloc (D.30941, 80);
            group->data.op[1].const_val = 0;
            D.32469 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.32469;
            group->prev = 0B;
            D.32470 = group->prev;
            group->next = D.32470;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.32471 = group->sreg3;
            group->sreg2 = D.32471;
            D.32472 = group->sreg2;
            group->sreg1 = D.32472;
            D.31162 = cfg->ip;
            group->cil_code = D.31162;
            group->data.op[0].src = f;
            group->data.op[1].src = 20B;
            D.32473 = got_loc->dreg;
            cons->sreg1 = D.32473;
            cons->data.op[1].p = group;
          }
          goto <D.32474>;
          <D.32468>:
          cons->data.op[0].p = f;
          cons->data.op[1].src = 20B;
          <D.32474>:
          cons->type = 3;
          D.32475 = alloc_dreg (cfg, 3);
          D.32476 = (int) D.32475;
          cons->dreg = D.32476;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.32477>; else goto <D.32478>;
          <D.32477>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = cons;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          cons->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = cons;
          goto <D.32479>;
          <D.32478>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = cons;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.32479>:
          D.32480 = alloc_freg (cfg);
          dreg = (int) D.32480;
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 396;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->dreg = dreg;
          D.32481 = cons->dreg;
          ins->sreg1 = D.32481;
          ins->data.op[0].const_val = 0;
          ins->type = 1;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.32482>; else goto <D.32483>;
          <D.32482>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.32484>;
          <D.32483>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.32484>:
          ins->type = 4;
        }
        goto <D.32485>;
        <D.32458>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 364;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->type = 4;
        D.32486 = alloc_dreg (cfg, 4);
        D.32487 = (int) D.32486;
        ins->dreg = D.32487;
        ins->data.op[0].p = f;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.32488>; else goto <D.32489>;
        <D.32488>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.32490>;
        <D.32489>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.32490>:
        <D.32485>:
        ip = ip + 1;
        {
          union mono_rfloat mf;

          try
            {
              D.32491 = MEM[(const guint32 *)ip];
              mf.ival = D.32491;
              D.32492 = mf.fval;
              *f = D.32492;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        ip = ip + 4;
        sp.99 = sp;
        sp = sp.99 + 8;
        *sp.99 = ins;
        goto <D.27857>;
      }
      <D.27904>:
      {
        double * d;
        gboolean use_aotconst;

        use_aotconst = 0;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.32494>; else goto <D.32495>;
        <D.32494>:
        use_aotconst = 1;
        <D.32495>:
        D.30966 = cfg->domain;
        d = mono_domain_alloc (D.30966, 8);
        D.32410 = ip + 9;
        if (D.32410 > end) goto <D.32496>; else goto <D.32497>;
        <D.32496>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32498>; else goto <D.32499>;
        <D.32498>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32500>; else goto <D.32501>;
        <D.32500>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32501>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32499>:
        D.32502 = mini_get_debug_options ();
        D.32503 = D.32502->break_on_unverified;
        if (D.32503 != 0) goto <D.32504>; else goto unverified;
        <D.32504>:
        raise (5);
        <D.32497>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.32505>; else goto <D.32506>;
        <D.32505>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32507>; else goto <D.32508>;
        <D.32507>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32509>; else goto <D.32510>;
        <D.32509>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32510>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32508>:
        D.32511 = mini_get_debug_options ();
        D.32512 = D.32511->break_on_unverified;
        if (D.32512 != 0) goto <D.32513>; else goto unverified;
        <D.32513>:
        raise (5);
        <D.32506>:
        if (use_aotconst != 0) goto <D.32514>; else goto <D.32515>;
        <D.32514>:
        {
          struct MonoInst * cons;
          int dreg;

          D.30941 = cfg->mempool;
          cons = mono_mempool_alloc (D.30941, 80);
          cons->data.op[1].const_val = 0;
          D.32516 = cons->data.op[1].const_val;
          cons->data.op[0].const_val = D.32516;
          cons->prev = 0B;
          D.32517 = cons->prev;
          cons->next = D.32517;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.32519>; else goto <D.32520>;
          <D.32519>:
          iftmp.100 = 734;
          goto <D.32521>;
          <D.32520>:
          iftmp.100 = 363;
          <D.32521>:
          cons->opcode = iftmp.100;
          cons->flags = 0;
          cons->type = 0;
          cons->dreg = -1;
          cons->sreg3 = -1;
          D.32522 = cons->sreg3;
          cons->sreg2 = D.32522;
          D.32523 = cons->sreg2;
          cons->sreg1 = D.32523;
          D.31162 = cfg->ip;
          cons->cil_code = D.31162;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.32524>; else goto <D.32525>;
          <D.32524>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.30941 = cfg->mempool;
            group = mono_mempool_alloc (D.30941, 80);
            group->data.op[1].const_val = 0;
            D.32526 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.32526;
            group->prev = 0B;
            D.32527 = group->prev;
            group->next = D.32527;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.32528 = group->sreg3;
            group->sreg2 = D.32528;
            D.32529 = group->sreg2;
            group->sreg1 = D.32529;
            D.31162 = cfg->ip;
            group->cil_code = D.31162;
            group->data.op[0].src = d;
            group->data.op[1].src = 21B;
            D.32530 = got_loc->dreg;
            cons->sreg1 = D.32530;
            cons->data.op[1].p = group;
          }
          goto <D.32531>;
          <D.32525>:
          cons->data.op[0].p = d;
          cons->data.op[1].src = 21B;
          <D.32531>:
          cons->type = 3;
          D.32532 = alloc_dreg (cfg, 3);
          D.32533 = (int) D.32532;
          cons->dreg = D.32533;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.32534>; else goto <D.32535>;
          <D.32534>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = cons;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          cons->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = cons;
          goto <D.32536>;
          <D.32535>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = cons;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.32536>:
          D.32537 = alloc_freg (cfg);
          dreg = (int) D.32537;
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 397;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->dreg = dreg;
          D.32538 = cons->dreg;
          ins->sreg1 = D.32538;
          ins->data.op[0].const_val = 0;
          ins->type = 1;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.32539>; else goto <D.32540>;
          <D.32539>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.32541>;
          <D.32540>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.32541>:
          ins->type = 4;
        }
        goto <D.32542>;
        <D.32515>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 365;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->type = 4;
        D.32543 = alloc_dreg (cfg, 4);
        D.32544 = (int) D.32543;
        ins->dreg = D.32544;
        ins->data.op[0].p = d;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.32545>; else goto <D.32546>;
        <D.32545>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.32547>;
        <D.32546>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.32547>:
        <D.32542>:
        ip = ip + 1;
        {
          union mono_rdouble mf;

          try
            {
              D.32431 = MEM[(const guint64 *)ip];
              mf.ival = D.32431;
              D.32548 = mf.fval;
              *d = D.32548;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        ip = ip + 8;
        sp.101 = sp;
        sp = sp.101 + 8;
        *sp.101 = ins;
        goto <D.27857>;
      }
      <D.27912>:
      {
        struct MonoInst * temp;
        struct MonoInst * store;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.32550>; else goto <D.32551>;
        <D.32550>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32552>; else goto <D.32553>;
        <D.32552>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32554>; else goto <D.32555>;
        <D.32554>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32555>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32553>:
        D.32556 = mini_get_debug_options ();
        D.32557 = D.32556->break_on_unverified;
        if (D.32557 != 0) goto <D.32558>; else goto unverified;
        <D.32558>:
        raise (5);
        <D.32551>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.32559>; else goto <D.32560>;
        <D.32559>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32561>; else goto <D.32562>;
        <D.32561>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32563>; else goto <D.32564>;
        <D.32563>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32564>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32562>:
        D.32565 = mini_get_debug_options ();
        D.32566 = D.32565->break_on_unverified;
        if (D.32566 != 0) goto <D.32567>; else goto unverified;
        <D.32567>:
        raise (5);
        <D.32560>:
        sp = sp + 18446744073709551608;
        ins = *sp;
        D.32568 = type_from_stack_type (ins);
        temp = mono_compile_create_var (cfg, D.32568, 329);
        D.30941 = cfg->mempool;
        store = mono_mempool_alloc (D.30941, 80);
        store->data.op[1].const_val = 0;
        D.32569 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.32569;
        store->prev = 0B;
        D.32570 = store->prev;
        store->next = D.32570;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.32571 = store->sreg3;
        store->sreg2 = D.32571;
        D.32572 = store->sreg2;
        store->sreg1 = D.32572;
        D.31162 = cfg->ip;
        store->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32579 = mono_type_to_regmove (cfg, D.32578);
        D.32580 = (short unsigned int) D.32579;
        store->opcode = D.32580;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32581 = D.32577->klass;
        store->klass = D.32581;
        D.31356 = ins->dreg;
        store->sreg1 = D.31356;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32582 = D.32577->dreg;
        store->dreg = D.32582;
        D.32583 = store->opcode;
        if (D.32583 == 427) goto <D.32584>; else goto <D.32585>;
        <D.32584>:
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32586 = mono_class_from_mono_type (D.32578);
        store->klass = D.32586;
        <D.32585>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.32587>; else goto <D.32588>;
        <D.32587>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = store;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        store->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        goto <D.32589>;
        <D.32588>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.32589>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32590 = mono_type_to_regmove (cfg, D.32578);
        D.32591 = (short unsigned int) D.32590;
        ins->opcode = D.32591;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.32578, ins);
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32581 = D.32577->klass;
        ins->klass = D.32581;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32582 = D.32577->dreg;
        ins->sreg1 = D.32582;
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.32592 = alloc_dreg (cfg, D.31706);
        D.32593 = (int) D.32592;
        ins->dreg = D.32593;
        D.31709 = ins->opcode;
        if (D.31709 == 427) goto <D.32594>; else goto <D.32595>;
        <D.32594>:
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32596 = mono_class_from_mono_type (D.32578);
        ins->klass = D.32596;
        <D.32595>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.32597>; else goto <D.32598>;
        <D.32597>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.32599>;
        <D.32598>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.32599>:
        sp.102 = sp;
        sp = sp.102 + 8;
        *sp.102 = ins;
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32601 = mono_type_to_regmove (cfg, D.32578);
        D.32602 = (short unsigned int) D.32601;
        ins->opcode = D.32602;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.32578, ins);
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32581 = D.32577->klass;
        ins->klass = D.32581;
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32582 = D.32577->dreg;
        ins->sreg1 = D.32582;
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.32603 = alloc_dreg (cfg, D.31706);
        D.32604 = (int) D.32603;
        ins->dreg = D.32604;
        D.31709 = ins->opcode;
        if (D.31709 == 427) goto <D.32605>; else goto <D.32606>;
        <D.32605>:
        D.31695 = cfg->varinfo;
        D.32573 = temp->data.op[0].const_val;
        D.32574 = (long unsigned int) D.32573;
        D.32575 = D.32574 * 8;
        D.32576 = D.31695 + D.32575;
        D.32577 = *D.32576;
        D.32578 = D.32577->data.op[1].vtype;
        D.32607 = mono_class_from_mono_type (D.32578);
        ins->klass = D.32607;
        <D.32606>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.32608>; else goto <D.32609>;
        <D.32608>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.32610>;
        <D.32609>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.32610>:
        sp.103 = sp;
        sp = sp.103 + 8;
        *sp.103 = ins;
        ip = ip + 1;
        inline_costs = inline_costs + 2;
        goto <D.27857>;
      }
      <D.27915>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.32612>; else goto <D.32613>;
      <D.32612>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.32614>; else goto <D.32615>;
      <D.32614>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.32616>; else goto <D.32617>;
      <D.32616>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.32617>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.32615>:
      D.32618 = mini_get_debug_options ();
      D.32619 = D.32618->break_on_unverified;
      if (D.32619 != 0) goto <D.32620>; else goto unverified;
      <D.32620>:
      raise (5);
      <D.32613>:
      ip = ip + 1;
      sp = sp + 18446744073709551608;
      goto <D.27857>;
      <D.27916>:
      {
        struct MonoCallInst * call;

        D.30911 = cfg->method;
        if (D.30911 != method) goto <D.32621>; else goto <D.32622>;
        <D.32621>:
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 == 0) goto <D.32623>; else goto <D.32624>;
        <D.32623>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.32625>; else goto <D.32626>;
        <D.32625>:
        printf ("inline failed: %s\n", "jmp");
        <D.32626>:
        goto inline_failure;
        <D.32624>:
        <D.32622>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32627>; else goto <D.32628>;
        <D.32627>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        D.32635 = mono_opcode_name (D.31839);
        D.32636 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.32635, "method-to-ir.c", 7539);
        cfg->exception_message = D.32636;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.32637>; else goto <D.32638>;
        <D.32637>:
        D.32639 = cfg->exception_message;
        printf ("%s\n", D.32639);
        <D.32638>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32628>:
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.32640>; else goto <D.32641>;
        <D.32640>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32642>; else goto <D.32643>;
        <D.32642>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32644>; else goto <D.32645>;
        <D.32644>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32645>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32643>:
        D.32646 = mini_get_debug_options ();
        D.32647 = D.32646->break_on_unverified;
        if (D.32647 != 0) goto <D.32648>; else goto unverified;
        <D.32648>:
        raise (5);
        <D.32641>:
        if (stack_start != sp) goto <D.32649>; else goto <D.32650>;
        <D.32649>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.32651>; else goto <D.32652>;
        <D.32651>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32653>; else goto <D.32654>;
        <D.32653>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.32654>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32652>:
        D.32655 = mini_get_debug_options ();
        D.32656 = D.32655->break_on_unverified;
        if (D.32656 != 0) goto <D.32657>; else goto unverified;
        <D.32657>:
        raise (5);
        <D.32650>:
        token = MEM[(const guint32 *)ip + 1B];
        cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
        if (cmethod == 0B) goto <D.32658>; else goto <D.32660>;
        <D.32660>:
        D.32661 = mono_loader_get_last_error ();
        if (D.32661 != 0B) goto <D.32658>; else goto <D.32659>;
        <D.32658>:
        D.32662 = mini_get_debug_options ();
        D.32663 = D.32662->break_on_unverified;
        if (D.32663 != 0) goto <D.32664>; else goto load_error;
        <D.32664>:
        raise (5);
        <D.32659>:
        D.30977 = cfg->generic_sharing_context;
        if (D.30977 != 0B) goto <D.32665>; else goto <D.32666>;
        <D.32665>:
        D.32667 = mono_method_check_context_used (cmethod);
        if (D.32667 != 0) goto <D.32668>; else goto <D.32669>;
        <D.32668>:
        D.30977 = cfg->generic_sharing_context;
        if (D.30977 != 0B) goto <D.32670>; else goto <D.32671>;
        <D.32670>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.32672>; else goto <D.32673>;
        <D.32672>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.32674 = mono_opcode_name (39);
        printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", D.32629, D.32630, D.32631, D.32634, D.32674, 7552);
        <D.32673>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.32671>:
        <D.32669>:
        <D.32666>:
        D.32675 = mono_security_get_mode ();
        if (D.32675 == 2) goto <D.32676>; else goto <D.32677>;
        <D.32676>:
        D.31510 = cfg->exception_type;
        if (D.31510 != 0) goto exception_exit; else goto <D.32678>;
        <D.32678>:
        <D.32677>:
        if (1 != 0) goto <D.32679>; else goto <D.32680>;
        <D.32679>:
        {
          struct MonoMethodSignature * fsig;
          int i;
          int n;

          fsig = mono_method_signature (cmethod);
          D.32681 = fsig->param_count;
          D.32682 = (int) D.32681;
          D.32683 = fsig->hasthis;
          D.32684 = (int) D.32683;
          n = D.32682 + D.32684;
          D.31021 = cfg->verbose_level;
          if (D.31021 > 1) goto <D.32685>; else goto <D.32686>;
          <D.32685>:
          printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 7564);
          <D.32686>:
          cfg->disable_aot = 1;
          D.30941 = cfg->mempool;
          call = mono_mempool_alloc0 (D.30941, 192);
          call->inst.opcode = 444;
          call->inst.dreg = -1;
          call->inst.sreg3 = -1;
          D.32687 = call->inst.sreg3;
          call->inst.sreg2 = D.32687;
          D.32688 = call->inst.sreg2;
          call->inst.sreg1 = D.32688;
          D.31162 = cfg->ip;
          call->inst.cil_code = D.31162;
          call->method = cmethod;
          call->tail_call = 1;
          D.32689 = mono_method_signature (cmethod);
          call->signature = D.32689;
          D.30941 = cfg->mempool;
          D.32690 = (long unsigned int) n;
          D.32691 = (unsigned int) D.32690;
          D.32692 = D.32691 * 8;
          D.32693 = mono_mempool_alloc (D.30941, D.32692);
          call->args = D.32693;
          call->inst.data.op[0].p = cmethod;
          i = 0;
          goto <D.27924>;
          <D.27923>:
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.30941 = cfg->mempool;
          D.32698 = mono_mempool_alloc (D.30941, 80);
          *D.32697 = D.32698;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->data.op[1].const_val = 0;
          D.32700 = D.32699->data.op[1].const_val;
          D.32699->data.op[0].const_val = D.32700;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->prev = 0B;
          D.32701 = D.32699->prev;
          D.32699->next = D.32701;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->opcode = 424;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->flags = 0;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->type = 0;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->dreg = -1;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32699->sreg3 = -1;
          D.32702 = D.32699->sreg3;
          D.32699->sreg2 = D.32702;
          D.32703 = D.32699->sreg2;
          D.32699->sreg1 = D.32703;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31162 = cfg->ip;
          D.32699->cil_code = D.31162;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31569 = cfg->arg_types;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32704 = D.31569 + D.32696;
          D.32705 = *D.32704;
          D.32706 = mono_type_to_regmove (cfg, D.32705);
          D.32707 = (short unsigned int) D.32706;
          D.32699->opcode = D.32707;
          D.31569 = cfg->arg_types;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32704 = D.31569 + D.32696;
          D.32705 = *D.32704;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          type_to_eval_stack_type (cfg, D.32705, D.32699);
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31559 = cfg->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32708 = D.31559 + D.32696;
          D.32709 = *D.32708;
          D.32710 = D.32709->klass;
          D.32699->klass = D.32710;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31559 = cfg->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32708 = D.31559 + D.32696;
          D.32709 = *D.32708;
          D.32711 = D.32709->dreg;
          D.32699->sreg1 = D.32711;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32712 = D.32699->type;
          D.32713 = (<unnamed type>) D.32712;
          D.32714 = alloc_dreg (cfg, D.32713);
          D.32715 = (int) D.32714;
          D.32699->dreg = D.32715;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.32716 = D.32699->opcode;
          if (D.32716 == 427) goto <D.32717>; else goto <D.32718>;
          <D.32717>:
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31569 = cfg->arg_types;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32704 = D.31569 + D.32696;
          D.32705 = *D.32704;
          D.32719 = mono_class_from_mono_type (D.32705);
          D.32699->klass = D.32719;
          <D.32718>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.32720>; else goto <D.32721>;
          <D.32720>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          D.31191->next = D.32699;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.32699->prev = D.31191;
          bblock.113 = cfg->cbb;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          bblock.113->last_ins = D.32699;
          goto <D.32722>;
          <D.32721>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          D.32694 = call->args;
          D.32695 = (long unsigned int) i;
          D.32696 = D.32695 * 8;
          D.32697 = D.32694 + D.32696;
          D.32699 = *D.32697;
          bblock.113->last_ins = D.32699;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.32722>:
          i = i + 1;
          <D.27924>:
          if (i < n) goto <D.27923>; else goto <D.27925>;
          <D.27925>:
          mono_arch_emit_call (cfg, call);
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          if (D.31279 != 0B) goto <D.32723>; else goto <D.32724>;
          <D.32723>:
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          D.31279->next = call;
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          MEM[(struct MonoInst *)call].prev = D.31279;
          bblock.70 = bblock;
          bblock.70->last_ins = call;
          goto <D.32725>;
          <D.32724>:
          bblock.70 = bblock;
          bblock.70 = bblock;
          bblock.70->last_ins = call;
          D.31279 = bblock.70->last_ins;
          bblock.70->code = D.31279;
          <D.32725>:
        }
        goto <D.32726>;
        <D.32680>:
        i = 0;
        goto <D.27927>;
        <D.27926>:
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.32727 = arg_array + D.31690;
        D.32728 = *D.32727;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.32727 = arg_array + D.31690;
        D.32728 = *D.32727;
        D.32729 = D.32728->flags;
        D.32730 = D.32729 | 4;
        D.32728->flags = D.32730;
        i = i + 1;
        <D.27927>:
        i.104 = (unsigned int) i;
        if (i.104 < num_args) goto <D.27926>; else goto <D.27928>;
        <D.27928>:
        D.30941 = cfg->mempool;
        call = mono_mempool_alloc0 (D.30941, 192);
        call->inst.opcode = 443;
        call->inst.dreg = -1;
        call->inst.sreg3 = -1;
        D.32687 = call->inst.sreg3;
        call->inst.sreg2 = D.32687;
        D.32688 = call->inst.sreg2;
        call->inst.sreg1 = D.32688;
        D.31162 = cfg->ip;
        call->inst.cil_code = D.31162;
        ins = call;
        ins->data.op[0].p = cmethod;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.32732>; else goto <D.32733>;
        <D.32732>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.32734>;
        <D.32733>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.32734>:
        <D.32726>:
        ip = ip + 5;
        start_new_bblock = 1;
        goto <D.27857>;
      }
      <D.27929>:
      <D.27930>:
      <D.27931>:
      {
        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.31838 = *ip;
            D.32735 = D.31838 == 111;
            virtual = (int) D.32735;
            D.31838 = *ip;
            D.32736 = D.31838 == 41;
            calli = (int) D.32736;
            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.31838 = *ip;
            call_opcode = (guint32) D.31838;
            emit_widen = 1;
            push_res = 1;
            skip_ret = 0;
            delegate_invoke = 0;
            D.32381 = ip + 5;
            if (D.32381 > end) goto <D.32737>; else goto <D.32738>;
            <D.32737>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.32739>; else goto <D.32740>;
            <D.32739>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.32741>; else goto <D.32742>;
            <D.32741>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32742>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32740>:
            D.32743 = mini_get_debug_options ();
            D.32744 = D.32743->break_on_unverified;
            if (D.32744 != 0) goto <D.32745>; else goto unverified;
            <D.32745>:
            raise (5);
            <D.32738>:
            token = MEM[(const guint32 *)ip + 1B];
            ins = 0B;
            if (calli != 0) goto <D.32746>; else goto <D.32747>;
            <D.32746>:
            cmethod = 0B;
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            if (D.31730 <= 7) goto <D.32748>; else goto <D.32749>;
            <D.32748>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.32750>; else goto <D.32751>;
            <D.32750>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.32752>; else goto <D.32753>;
            <D.32752>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32753>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32751>:
            D.32754 = mini_get_debug_options ();
            D.32755 = D.32754->break_on_unverified;
            if (D.32755 != 0) goto <D.32756>; else goto unverified;
            <D.32756>:
            raise (5);
            <D.32749>:
            sp = sp + 18446744073709551608;
            addr = *sp;
            fsig = mini_get_signature (method, token, generic_context);
            D.32757 = fsig->param_count;
            D.32758 = (int) D.32757;
            D.32759 = fsig->hasthis;
            D.32760 = (int) D.32759;
            n = D.32758 + D.32760;
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.32761 = D.30883 & 512;
            if (D.32761 != 0) goto <D.32762>; else goto <D.32763>;
            <D.32762>:
            D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.32765 = D.32764 & 72057594037927936;
            if (D.32765 != 0) goto <D.32766>; else goto <D.32767>;
            <D.32766>:
            {
              struct MonoInst * args[3];

              try
                {
                  D.30941 = cfg->mempool;
                  D.32768 = mono_mempool_alloc (D.30941, 80);
                  args[0] = D.32768;
                  D.32769 = args[0];
                  D.32769 = args[0];
                  D.32769->data.op[1].const_val = 0;
                  D.32770 = D.32769->data.op[1].const_val;
                  D.32769->data.op[0].const_val = D.32770;
                  D.32769 = args[0];
                  D.32769 = args[0];
                  D.32769->prev = 0B;
                  D.32771 = D.32769->prev;
                  D.32769->next = D.32771;
                  D.32769 = args[0];
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.32773>; else goto <D.32774>;
                  <D.32773>:
                  iftmp.105 = 734;
                  goto <D.32775>;
                  <D.32774>:
                  iftmp.105 = 363;
                  <D.32775>:
                  D.32769->opcode = iftmp.105;
                  D.32769 = args[0];
                  D.32769->flags = 0;
                  D.32769 = args[0];
                  D.32769->type = 0;
                  D.32769 = args[0];
                  D.32769->dreg = -1;
                  D.32769 = args[0];
                  D.32769 = args[0];
                  D.32769 = args[0];
                  D.32769->sreg3 = -1;
                  D.32776 = D.32769->sreg3;
                  D.32769->sreg2 = D.32776;
                  D.32777 = D.32769->sreg2;
                  D.32769->sreg1 = D.32777;
                  D.32769 = args[0];
                  D.31162 = cfg->ip;
                  D.32769->cil_code = D.31162;
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.32778>; else goto <D.32779>;
                  <D.32778>:
                  {
                    struct MonoInst * group;
                    struct MonoInst * got_loc;

                    got_loc = mono_get_got_var (cfg);
                    D.30941 = cfg->mempool;
                    group = mono_mempool_alloc (D.30941, 80);
                    group->data.op[1].const_val = 0;
                    D.32780 = group->data.op[1].const_val;
                    group->data.op[0].const_val = D.32780;
                    group->prev = 0B;
                    D.32781 = group->prev;
                    group->next = D.32781;
                    group->opcode = 733;
                    group->flags = 0;
                    group->type = 0;
                    group->dreg = -1;
                    group->sreg3 = -1;
                    D.32782 = group->sreg3;
                    group->sreg2 = D.32782;
                    D.32783 = group->sreg2;
                    group->sreg1 = D.32783;
                    D.31162 = cfg->ip;
                    group->cil_code = D.31162;
                    D.30878 = method->klass;
                    D.30879 = D.30878->image;
                    group->data.op[0].src = D.30879;
                    group->data.op[1].src = 12B;
                    D.32769 = args[0];
                    D.32784 = got_loc->dreg;
                    D.32769->sreg1 = D.32784;
                    D.32769 = args[0];
                    D.32769->data.op[1].p = group;
                  }
                  goto <D.32785>;
                  <D.32779>:
                  D.32769 = args[0];
                  D.30878 = method->klass;
                  D.30879 = D.30878->image;
                  D.32769->data.op[0].p = D.30879;
                  D.32769 = args[0];
                  D.32769->data.op[1].src = 12B;
                  <D.32785>:
                  D.32769 = args[0];
                  D.32769->type = 3;
                  D.32769 = args[0];
                  D.32786 = alloc_dreg (cfg, 3);
                  D.32787 = (int) D.32786;
                  D.32769->dreg = D.32787;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.32788>; else goto <D.32789>;
                  <D.32788>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.32769 = args[0];
                  D.31191->next = D.32769;
                  D.32769 = args[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.32769->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.32769 = args[0];
                  bblock.113->last_ins = D.32769;
                  goto <D.32790>;
                  <D.32789>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.32769 = args[0];
                  bblock.113->last_ins = D.32769;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.32790>:
                  D.30941 = cfg->mempool;
                  D.32791 = mono_mempool_alloc (D.30941, 80);
                  args[1] = D.32791;
                  D.32792 = args[1];
                  D.32792 = args[1];
                  D.32792->data.op[1].const_val = 0;
                  D.32793 = D.32792->data.op[1].const_val;
                  D.32792->data.op[0].const_val = D.32793;
                  D.32792 = args[1];
                  D.32792 = args[1];
                  D.32792->prev = 0B;
                  D.32794 = D.32792->prev;
                  D.32792->next = D.32794;
                  D.32792 = args[1];
                  D.32792->opcode = 363;
                  D.32792 = args[1];
                  D.32792->flags = 0;
                  D.32792 = args[1];
                  D.32792->type = 0;
                  D.32792 = args[1];
                  D.32792->dreg = -1;
                  D.32792 = args[1];
                  D.32792 = args[1];
                  D.32792 = args[1];
                  D.32792->sreg3 = -1;
                  D.32795 = D.32792->sreg3;
                  D.32792->sreg2 = D.32795;
                  D.32796 = D.32792->sreg2;
                  D.32792->sreg1 = D.32796;
                  D.32792 = args[1];
                  D.31162 = cfg->ip;
                  D.32792->cil_code = D.31162;
                  D.32792 = args[1];
                  D.32792->data.op[0].p = fsig;
                  D.32792 = args[1];
                  D.32792->type = 3;
                  D.32792 = args[1];
                  D.32797 = alloc_dreg (cfg, 3);
                  D.32798 = (int) D.32797;
                  D.32792->dreg = D.32798;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.32799>; else goto <D.32800>;
                  <D.32799>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.32792 = args[1];
                  D.31191->next = D.32792;
                  D.32792 = args[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.32792->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.32792 = args[1];
                  bblock.113->last_ins = D.32792;
                  goto <D.32801>;
                  <D.32800>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.32792 = args[1];
                  bblock.113->last_ins = D.32792;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.32801>:
                  args[2] = addr;
                  addr = mono_emit_jit_icall (cfg, mono_get_native_calli_wrapper, &args);
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            <D.32767>:
            <D.32763>:
            goto <D.32802>;
            <D.32747>:
            {
              struct MonoMethod * cil_method;

              try
                {
                  cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
                  cil_method = cmethod;
                  if (constrained_call != 0B) goto <D.32803>; else goto <D.32804>;
                  <D.32803>:
                  D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30884 = D.30883 & 124;
                  if (D.30884 != 0) goto <D.32805>; else goto <D.32806>;
                  <D.32805>:
                  D.31021 = cfg->verbose_level;
                  if (D.31021 > 2) goto <D.32807>; else goto <D.32808>;
                  <D.32807>:
                  D.32809 = mono_type_get_full_name (constrained_call);
                  printf ("DM Constrained call to %s\n", D.32809);
                  <D.32808>:
                  D.32813 = constrained_call->byval_arg.type;
                  if (D.32813 != 19) goto <D.32814>; else goto <D.32810>;
                  <D.32814>:
                  D.32813 = constrained_call->byval_arg.type;
                  if (D.32813 != 30) goto <D.32811>; else goto <D.32810>;
                  <D.32810>:
                  D.30977 = cfg->generic_sharing_context;
                  if (D.30977 == 0B) goto <D.32811>; else goto <D.32812>;
                  <D.32811>:
                  cil_method.106 = cil_method;
                  cmethod = mono_get_method_constrained_with_method (image, cil_method.106, constrained_call, generic_context);
                  <D.32812>:
                  goto <D.32816>;
                  <D.32806>:
                  D.31021 = cfg->verbose_level;
                  if (D.31021 > 2) goto <D.32817>; else goto <D.32818>;
                  <D.32817>:
                  D.32819 = mono_type_get_full_name (constrained_call);
                  printf ("Constrained call to %s\n", D.32819);
                  <D.32818>:
                  D.32813 = constrained_call->byval_arg.type;
                  if (D.32813 == 19) goto <D.32820>; else goto <D.32823>;
                  <D.32823>:
                  D.32813 = constrained_call->byval_arg.type;
                  if (D.32813 == 30) goto <D.32820>; else goto <D.32821>;
                  <D.32820>:
                  D.30977 = cfg->generic_sharing_context;
                  if (D.30977 != 0B) goto <D.32824>; else goto <D.32821>;
                  <D.32824>:
                  D.32825 = mini_is_gsharedvt_klass (cfg, constrained_call);
                  if (D.32825 == 0) goto <D.32826>; else goto <D.32827>;
                  <D.32826>:
                  D.32828 = cmethod->klass;
                  D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
                  D.32830 = D.32829 & 8;
                  D.32831 = D.32830 != 0;
                  D.32832 = (long int) D.32831;
                  D.32833 = __builtin_expect (D.32832, 0);
                  if (D.32833 != 0) goto <D.32834>; else goto <D.32835>;
                  <D.32834>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7671, "!cmethod->klass->valuetype");
                  <D.32835>:
                  <D.32827>:
                  goto <D.32822>;
                  <D.32821>:
                  cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
                  <D.32822>:
                  <D.32816>:
                  <D.32804>:
                  if (cmethod == 0B) goto <D.32836>; else goto <D.32838>;
                  <D.32838>:
                  D.32839 = mono_loader_get_last_error ();
                  if (D.32839 != 0B) goto <D.32836>; else goto <D.32837>;
                  <D.32836>:
                  D.32840 = mini_get_debug_options ();
                  D.32841 = D.32840->break_on_unverified;
                  if (D.32841 != 0) goto <D.32842>; else goto load_error;
                  <D.32842>:
                  raise (5);
                  <D.32837>:
                  if (dont_verify == 0) goto <D.32843>; else goto <D.32844>;
                  <D.32843>:
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.32845 = D.31336 & 70368744177664;
                  if (D.32845 == 0) goto <D.32846>; else goto <D.32847>;
                  <D.32846>:
                  {
                    struct MonoMethod * target_method;

                    target_method = cil_method;
                    D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                    D.30991 = D.30883 & 4096;
                    if (D.30991 != 0) goto <D.32848>; else goto <D.32849>;
                    <D.32848>:
                    D.32850 = mono_method_get_generic_container (method_definition);
                    D.32851 = &D.32850->context;
                    target_method = mini_get_method_allow_open (method, token, 0B, D.32851);
                    <D.32849>:
                    D.32852 = mono_method_can_access_method (method_definition, target_method);
                    if (D.32852 == 0) goto <D.32853>; else goto <D.32854>;
                    <D.32853>:
                    cil_method.106 = cil_method;
                    D.32855 = mono_method_can_access_method (method, cil_method.106);
                    if (D.32855 == 0) goto <D.32856>; else goto <D.32857>;
                    <D.32856>:
                    {
                      char * method_fname;
                      char * cil_method_fname;

                      method_fname = mono_method_full_name (method, 1);
                      cil_method.106 = cil_method;
                      cil_method_fname = mono_method_full_name (cil_method.106, 1);
                      mono_cfg_set_exception (cfg, 9);
                      D.32858 = monoeg_g_strdup_printf ("Method `%s\' is inaccessible from method `%s\'\n", cil_method_fname, method_fname);
                      cfg->exception_message = D.32858;
                      monoeg_g_free (method_fname);
                      monoeg_g_free (cil_method_fname);
                      goto exception_exit;
                    }
                    <D.32857>:
                    <D.32854>:
                  }
                  <D.32847>:
                  <D.32844>:
                  D.32859 = mono_security_get_mode ();
                  if (D.32859 == 1) goto <D.32860>; else goto <D.32861>;
                  <D.32860>:
                  cil_method.106 = cil_method;
                  bblock.70 = bblock;
                  ensure_method_is_allowed_to_call_method (cfg, method, cil_method.106, bblock.70, ip);
                  <D.32861>:
                  if (virtual == 0) goto <D.32862>; else goto <D.32863>;
                  <D.32862>:
                  D.32864 = cmethod->flags;
                  D.32865 = (int) D.32864;
                  D.32866 = D.32865 & 1024;
                  if (D.32866 != 0) goto <D.32867>; else goto <D.32868>;
                  <D.32867>:
                  virtual = 1;
                  <D.32868>:
                  <D.32863>:
                  {
                    const int test_flags;
                    const int expected_flags;

                    test_flags = 112;
                    expected_flags = 96;
                    if (virtual == 0) goto <D.32869>; else goto <D.32870>;
                    <D.32869>:
                    D.32828 = cmethod->klass;
                    D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
                    D.32871 = D.32829 & 4194304;
                    if (D.32871 != 0) goto <D.32872>; else goto <D.32873>;
                    <D.32872>:
                    D.32864 = cmethod->flags;
                    D.32865 = (int) D.32864;
                    D.32874 = D.32865 & 112;
                    if (D.32874 == 96) goto <D.32875>; else goto <D.32876>;
                    <D.32875>:
                    D.30911 = cfg->method;
                    D.32877 = BIT_FIELD_REF <*D.30911, 64, 256>;
                    D.32878 = D.32877 & 124;
                    if (D.32878 == 0) goto <D.32879>; else goto <D.32880>;
                    <D.32879>:
                    virtual = 1;
                    <D.32880>:
                    <D.32876>:
                    <D.32873>:
                    <D.32870>:
                  }
                  D.32828 = cmethod->klass;
                  D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
                  D.32881 = D.32829 & 1;
                  if (D.32881 == 0) goto <D.32882>; else goto <D.32883>;
                  <D.32882>:
                  D.32828 = cmethod->klass;
                  D.32884 = mono_class_init (D.32828);
                  if (D.32884 == 0) goto <D.32885>; else goto <D.32886>;
                  <D.32885>:
                  D.32887 = mini_get_debug_options ();
                  D.32888 = D.32887->break_on_unverified;
                  if (D.32888 != 0) goto <D.32889>; else goto <D.32890>;
                  <D.32889>:
                  raise (5);
                  goto <D.32891>;
                  <D.32890>:
                  D.32828 = cmethod->klass;
                  cfg->exception_ptr = D.32828;
                  goto load_error;
                  <D.32891>:
                  <D.32886>:
                  <D.32883>:
                  D.32894 = cmethod->iflags;
                  D.32895 = (int) D.32894;
                  D.32896 = D.32895 & 4096;
                  if (D.32896 != 0) goto <D.32897>; else goto <D.32892>;
                  <D.32897>:
                  D.32828 = cmethod->klass;
                  D.32898 = mini_class_is_system_array (D.32828);
                  if (D.32898 != 0) goto <D.32899>; else goto <D.32892>;
                  <D.32899>:
                  D.32828 = cmethod->klass;
                  D.32900 = D.32828->rank;
                  array_rank = (int) D.32900;
                  fsig = mono_method_signature (cmethod);
                  goto <D.32893>;
                  <D.32892>:
                  fsig = mono_method_signature (cmethod);
                  if (fsig == 0B) goto <D.32901>; else goto <D.32902>;
                  <D.32901>:
                  D.32903 = mini_get_debug_options ();
                  D.32904 = D.32903->break_on_unverified;
                  if (D.32904 != 0) goto <D.32905>; else goto load_error;
                  <D.32905>:
                  raise (5);
                  <D.32902>:
                  D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.32765 = D.32764 & 72057594037927936;
                  if (D.32765 != 0) goto <D.32906>; else goto <D.32907>;
                  <D.32906>:
                  {
                    struct MonoMethod * wrapper;

                    check_for_pending_exc.107 = check_for_pending_exc;
                    D.32909 = cfg->compile_aot;
                    D.32910 = (int) D.32909;
                    wrapper = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc.107, D.32910);
                    fsig = mono_method_signature (wrapper);
                  }
                  goto <D.32911>;
                  <D.32907>:
                  if (constrained_call != 0B) goto <D.32912>; else goto <D.32913>;
                  <D.32912>:
                  fsig = mono_method_signature (cmethod);
                  goto <D.32914>;
                  <D.32913>:
                  fsig = mono_method_get_signature_full (cmethod, image, token, generic_context);
                  <D.32914>:
                  <D.32911>:
                  <D.32893>:
                  cil_method.106 = cil_method;
                  mono_save_token_info (cfg, image, token, cil_method.106);
                  D.32915 = fsig->ret;
                  D.32916 = mono_type_is_void (D.32915);
                  if (D.32916 == 0) goto <D.32917>; else goto <D.32918>;
                  <D.32917>:
                  D.32381 = ip + 5;
                  if (D.32381 >= end) goto <D.32921>; else goto <D.32922>;
                  <D.32922>:
                  D.32381 = ip + 5;
                  D.32923 = *D.32381;
                  if (D.32923 != 38) goto <D.32924>; else goto <D.32920>;
                  <D.32924>:
                  D.32381 = ip + 5;
                  D.32923 = *D.32381;
                  if (D.32923 != 0) goto <D.32921>; else goto <D.32920>;
                  <D.32921>:
                  if (seq_point_locs == 0B) goto <D.32919>; else goto <D.32925>;
                  <D.32925>:
                  D.32381 = ip + 5;
                  D.32926 = (long int) D.32381;
                  D.31088 = header->code;
                  D.31650 = (long int) D.31088;
                  D.32927 = D.32926 - D.31650;
                  D.32928 = (long unsigned int) D.32927;
                  D.32929 = D.32928 / 64;
                  D.32930 = seq_point_locs->data[D.32929];
                  D.32381 = ip + 5;
                  D.32926 = (long int) D.32381;
                  D.31088 = header->code;
                  D.31650 = (long int) D.31088;
                  D.32927 = D.32926 - D.31650;
                  D.32931 = (int) D.32927;
                  D.32932 = D.32931 & 63;
                  D.32933 = D.32930 >> D.32932;
                  D.32934 = D.32933 & 1;
                  if (D.32934 == 0) goto <D.32919>; else goto <D.32920>;
                  <D.32919>:
                  need_seq_point = 1;
                  <D.32920>:
                  <D.32918>:
                  D.32757 = fsig->param_count;
                  D.32758 = (int) D.32757;
                  D.32759 = fsig->hasthis;
                  D.32760 = (int) D.32759;
                  n = D.32758 + D.32760;
                  D.32935 = mono_security_get_mode ();
                  if (D.32935 == 2) goto <D.32936>; else goto <D.32937>;
                  <D.32936>:
                  D.32938 = check_linkdemand (cfg, method, cmethod);
                  if (D.32938 != 0) goto <D.32939>; else goto <D.32940>;
                  <D.32939>:
                  D.30911 = cfg->method;
                  if (D.30911 != method) goto <D.32941>; else goto <D.32942>;
                  <D.32941>:
                  D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30884 = D.30883 & 124;
                  if (D.30884 == 0) goto <D.32943>; else goto <D.32944>;
                  <D.32943>:
                  D.31021 = cfg->verbose_level;
                  if (D.31021 > 1) goto <D.32945>; else goto <D.32946>;
                  <D.32945>:
                  printf ("inline failed: %s\n", "linkdemand");
                  <D.32946>:
                  goto inline_failure;
                  <D.32944>:
                  <D.32942>:
                  <D.32940>:
                  D.31510 = cfg->exception_type;
                  if (D.31510 != 0) goto exception_exit; else goto <D.32947>;
                  <D.32947>:
                  <D.32937>:
                  D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
                  D.32949 = D.32948 & 128;
                  if (D.32949 != 0) goto <D.32950>; else goto <D.32951>;
                  <D.32950>:
                  D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30884 = D.30883 & 124;
                  if (D.30884 != 16) goto <D.32952>; else goto <D.32953>;
                  <D.32952>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 7769);
                  <D.32953>:
                  <D.32951>:
                }
              finally
                {
                  cil_method = {CLOBBER};
                }
            }
            <D.32802>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 == 0B) goto <D.32954>; else goto <D.32955>;
            <D.32954>:
            if (cmethod != 0B) goto <D.32956>; else goto <D.32957>;
            <D.32956>:
            D.32828 = cmethod->klass;
            D.32958 = D.32828->generic_container;
            if (D.32958 != 0B) goto <D.32959>; else goto <D.32960>;
            <D.32959>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.32961>; else goto <D.32962>;
            <D.32961>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.32963>; else goto <D.32964>;
            <D.32963>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32964>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32962>:
            D.32965 = mini_get_debug_options ();
            D.32966 = D.32965->break_on_unverified;
            if (D.32966 != 0) goto <D.32967>; else goto unverified;
            <D.32967>:
            raise (5);
            <D.32960>:
            <D.32957>:
            <D.32955>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 == 0B) goto <D.32968>; else goto <D.32969>;
            <D.32968>:
            if (cmethod != 0B) goto <D.32970>; else goto <D.32971>;
            <D.32970>:
            D.32972 = mono_method_check_context_used (cmethod);
            D.32973 = D.32972 != 0;
            D.32974 = (long int) D.32973;
            D.32975 = __builtin_expect (D.32974, 0);
            if (D.32975 != 0) goto <D.32976>; else goto <D.32977>;
            <D.32976>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7776, "!mono_method_check_context_used (cmethod)");
            <D.32977>:
            <D.32971>:
            <D.32969>:
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.32978 = (long int) n;
            if (D.31731 < D.32978) goto <D.32979>; else goto <D.32980>;
            <D.32979>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.32981>; else goto <D.32982>;
            <D.32981>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.32983>; else goto <D.32984>;
            <D.32983>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32984>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32982>:
            D.32985 = mini_get_debug_options ();
            D.32986 = D.32985->break_on_unverified;
            if (D.32986 != 0) goto <D.32987>; else goto unverified;
            <D.32987>:
            raise (5);
            <D.32980>:
            D.31883 = (long unsigned int) n;
            D.31884 = D.31883 * 8;
            D.32988 = -D.31884;
            sp = sp + D.32988;
            if (constrained_call != 0B) goto <D.32989>; else goto <D.32990>;
            <D.32989>:
            D.32991 = mini_is_gsharedvt_klass (cfg, constrained_call);
            if (D.32991 != 0) goto <D.32992>; else goto <D.32993>;
            <D.32992>:
            D.32828 = cmethod->klass;
            D.32996 = mono_defaults.object_class;
            if (D.32828 != D.32996) goto <D.32997>; else goto <D.32994>;
            <D.32997>:
            D.32998 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32999 = D.32998 & 8;
            if (D.32999 != 0) goto <D.33000>; else goto <D.32994>;
            <D.33000>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32830 = D.32829 & 8;
            if (D.32830 != 0) goto <D.33001>; else goto <D.32994>;
            <D.33001>:
            goto <D.32995>;
            <D.32994>:
            D.32828 = cmethod->klass;
            D.33004 = D.32828->image;
            D.33005 = mono_defaults.corlib;
            if (D.33004 != D.33005) goto <D.33006>; else goto <D.33002>;
            <D.33006>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33008 = D.33007 & 32;
            if (D.33008 == 0) goto <D.33009>; else goto <D.33002>;
            <D.33009>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32830 = D.32829 & 8;
            if (D.32830 == 0) goto <D.33010>; else goto <D.33002>;
            <D.33010>:
            goto <D.33003>;
            <D.33002>:
            D.32828 = cmethod->klass;
            D.32996 = mono_defaults.object_class;
            if (D.32828 == D.32996) goto <D.33011>; else goto <D.33016>;
            <D.33016>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33008 = D.33007 & 32;
            if (D.33008 != 0) goto <D.33011>; else goto <D.33017>;
            <D.33017>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32830 = D.32829 & 8;
            if (D.32830 == 0) goto <D.33018>; else goto <D.33012>;
            <D.33018>:
            D.32828 = cmethod->klass;
            D.33004 = D.32828->image;
            D.33005 = mono_defaults.corlib;
            if (D.33004 != D.33005) goto <D.33011>; else goto <D.33012>;
            <D.33011>:
            D.32915 = fsig->ret;
            D.33019 = mono_type_is_void (D.32915);
            if (D.33019 != 0) goto <D.33013>; else goto <D.33020>;
            <D.33020>:
            D.32915 = fsig->ret;
            D.33021 = BIT_FIELD_REF <*D.32915, 64, 64>;
            D.33022 = D.33021 & 1073741824;
            if (D.33022 == 0) goto <D.33023>; else goto <D.33014>;
            <D.33023>:
            D.32915 = fsig->ret;
            D.33024 = D.32915->type;
            D.33025 = D.33024 + 254;
            if (D.33025 <= 11) goto <D.33013>; else goto <D.33026>;
            <D.33026>:
            D.32915 = fsig->ret;
            D.33024 = D.32915->type;
            D.33027 = D.33024 + 232;
            if (D.33027 <= 1) goto <D.33013>; else goto <D.33014>;
            <D.33014>:
            D.32915 = fsig->ret;
            D.33028 = mono_type_is_reference (D.32915);
            if (D.33028 != 0) goto <D.33013>; else goto <D.33029>;
            <D.33029>:
            D.32915 = fsig->ret;
            D.33030 = mini_is_gsharedvt_type (cfg, D.32915);
            if (D.33030 != 0) goto <D.33013>; else goto <D.33012>;
            <D.33013>:
            D.32757 = fsig->param_count;
            if (D.32757 == 0) goto <D.33015>; else goto <D.33031>;
            <D.33031>:
            D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.33032 = D.32764 & 18014398509547519;
            if (D.33032 == 1) goto <D.33015>; else goto <D.33033>;
            <D.33033>:
            D.32757 = fsig->param_count;
            if (D.32757 == 1) goto <D.33034>; else goto <D.33012>;
            <D.33034>:
            D.33035 = fsig->params[0];
            D.33036 = mono_type_is_reference (D.33035);
            if (D.33036 != 0) goto <D.33015>; else goto <D.33037>;
            <D.33037>:
            D.33035 = fsig->params[0];
            D.33038 = mini_is_gsharedvt_type (cfg, D.33035);
            if (D.33038 != 0) goto <D.33015>; else goto <D.33012>;
            <D.33015>:
            {
              struct MonoInst * args[16];

              try
                {
                  D.31957 = *sp;
                  args[0] = D.31957;
                  D.33039 = mono_method_check_context_used (cmethod);
                  if (D.33039 != 0) goto <D.33040>; else goto <D.33041>;
                  <D.33040>:
                  D.33042 = mono_method_check_context_used (cmethod);
                  D.33043 = emit_get_rgctx_method (cfg, D.33042, cmethod, 5);
                  args[1] = D.33043;
                  goto <D.33044>;
                  <D.33041>:
                  D.30941 = cfg->mempool;
                  D.33045 = mono_mempool_alloc (D.30941, 80);
                  args[1] = D.33045;
                  D.33046 = args[1];
                  D.33046 = args[1];
                  D.33046->data.op[1].const_val = 0;
                  D.33047 = D.33046->data.op[1].const_val;
                  D.33046->data.op[0].const_val = D.33047;
                  D.33046 = args[1];
                  D.33046 = args[1];
                  D.33046->prev = 0B;
                  D.33048 = D.33046->prev;
                  D.33046->next = D.33048;
                  D.33046 = args[1];
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.33050>; else goto <D.33051>;
                  <D.33050>:
                  iftmp.108 = 734;
                  goto <D.33052>;
                  <D.33051>:
                  iftmp.108 = 363;
                  <D.33052>:
                  D.33046->opcode = iftmp.108;
                  D.33046 = args[1];
                  D.33046->flags = 0;
                  D.33046 = args[1];
                  D.33046->type = 0;
                  D.33046 = args[1];
                  D.33046->dreg = -1;
                  D.33046 = args[1];
                  D.33046 = args[1];
                  D.33046 = args[1];
                  D.33046->sreg3 = -1;
                  D.33053 = D.33046->sreg3;
                  D.33046->sreg2 = D.33053;
                  D.33054 = D.33046->sreg2;
                  D.33046->sreg1 = D.33054;
                  D.33046 = args[1];
                  D.31162 = cfg->ip;
                  D.33046->cil_code = D.31162;
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.33055>; else goto <D.33056>;
                  <D.33055>:
                  {
                    struct MonoInst * group;
                    struct MonoInst * got_loc;

                    got_loc = mono_get_got_var (cfg);
                    D.30941 = cfg->mempool;
                    group = mono_mempool_alloc (D.30941, 80);
                    group->data.op[1].const_val = 0;
                    D.33057 = group->data.op[1].const_val;
                    group->data.op[0].const_val = D.33057;
                    group->prev = 0B;
                    D.33058 = group->prev;
                    group->next = D.33058;
                    group->opcode = 733;
                    group->flags = 0;
                    group->type = 0;
                    group->dreg = -1;
                    group->sreg3 = -1;
                    D.33059 = group->sreg3;
                    group->sreg2 = D.33059;
                    D.33060 = group->sreg2;
                    group->sreg1 = D.33060;
                    D.31162 = cfg->ip;
                    group->cil_code = D.31162;
                    group->data.op[0].src = cmethod;
                    group->data.op[1].src = 6B;
                    D.33046 = args[1];
                    D.33061 = got_loc->dreg;
                    D.33046->sreg1 = D.33061;
                    D.33046 = args[1];
                    D.33046->data.op[1].p = group;
                  }
                  goto <D.33062>;
                  <D.33056>:
                  D.33046 = args[1];
                  D.33046->data.op[0].p = cmethod;
                  D.33046 = args[1];
                  D.33046->data.op[1].src = 6B;
                  <D.33062>:
                  D.33046 = args[1];
                  D.33046->type = 3;
                  D.33046 = args[1];
                  D.33063 = alloc_dreg (cfg, 3);
                  D.33064 = (int) D.33063;
                  D.33046->dreg = D.33064;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33065>; else goto <D.33066>;
                  <D.33065>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33046 = args[1];
                  D.31191->next = D.33046;
                  D.33046 = args[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33046->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33046 = args[1];
                  bblock.113->last_ins = D.33046;
                  goto <D.33067>;
                  <D.33066>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33046 = args[1];
                  bblock.113->last_ins = D.33046;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33067>:
                  <D.33044>:
                  D.33068 = mono_class_check_context_used (constrained_call);
                  D.33069 = emit_get_rgctx_klass (cfg, D.33068, constrained_call, 1);
                  args[2] = D.33069;
                  D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.33072 = D.32764 & 18014398509481984;
                  if (D.33072 != 0) goto <D.33073>; else goto <D.33070>;
                  <D.33073>:
                  D.32757 = fsig->param_count;
                  if (D.32757 != 0) goto <D.33074>; else goto <D.33070>;
                  <D.33074>:
                  D.30941 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30941, 80);
                  ins->data.op[1].const_val = 0;
                  D.31158 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.31158;
                  ins->prev = 0B;
                  D.31159 = ins->prev;
                  ins->next = D.31159;
                  ins->opcode = 339;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.31160 = ins->sreg3;
                  ins->sreg2 = D.31160;
                  D.31161 = ins->sreg2;
                  ins->sreg1 = D.31161;
                  D.31162 = cfg->ip;
                  ins->cil_code = D.31162;
                  D.33075 = alloc_preg (cfg);
                  D.33076 = (int) D.33075;
                  ins->dreg = D.33076;
                  D.32757 = fsig->param_count;
                  D.33077 = (long unsigned int) D.32757;
                  D.33078 = D.33077 * 8;
                  D.33079 = (long int) D.33078;
                  ins->data.op[1].const_val = D.33079;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33080>; else goto <D.33081>;
                  <D.33080>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = ins;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  ins->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  goto <D.33082>;
                  <D.33081>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33082>:
                  args[4] = ins;
                  D.33035 = fsig->params[0];
                  D.33083 = mini_is_gsharedvt_type (cfg, D.33035);
                  if (D.33083 != 0) goto <D.33084>; else goto <D.33085>;
                  <D.33084>:
                  {
                    int addr_reg;

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

                      D.33089 = sp + 8;
                      D.33090 = *D.33089;
                      D.33091 = D.33090->dreg;
                      D.33092 = (unsigned int) D.33091;
                      D.32058 = cfg->vreg_to_inst_len;
                      if (D.33092 < D.32058) goto <D.33093>; else goto <D.33094>;
                      <D.33093>:
                      D.32061 = cfg->vreg_to_inst;
                      D.33089 = sp + 8;
                      D.33090 = *D.33089;
                      D.33091 = D.33090->dreg;
                      D.33095 = (long unsigned int) D.33091;
                      D.33096 = D.33095 * 8;
                      D.33097 = D.32061 + D.33096;
                      iftmp.109 = *D.33097;
                      goto <D.33098>;
                      <D.33094>:
                      iftmp.109 = 0B;
                      <D.33098>:
                      var = iftmp.109;
                      if (var == 0B) goto <D.33099>; else goto <D.33100>;
                      <D.33099>:
                      D.33035 = fsig->params[0];
                      D.33089 = sp + 8;
                      D.33090 = *D.33089;
                      D.33091 = D.33090->dreg;
                      var = mono_compile_create_var_for_vreg (cfg, D.33035, 329, D.33091);
                      <D.33100>:
                      D.30941 = cfg->mempool;
                      ins = mono_mempool_alloc (D.30941, 80);
                      ins->data.op[1].const_val = 0;
                      D.31158 = ins->data.op[1].const_val;
                      ins->data.op[0].const_val = D.31158;
                      ins->prev = 0B;
                      D.31159 = ins->prev;
                      ins->next = D.31159;
                      ins->opcode = 314;
                      ins->flags = 0;
                      ins->type = 0;
                      ins->dreg = -1;
                      ins->sreg3 = -1;
                      D.31160 = ins->sreg3;
                      ins->sreg2 = D.31160;
                      D.31161 = ins->sreg2;
                      ins->sreg1 = D.31161;
                      D.31162 = cfg->ip;
                      ins->cil_code = D.31162;
                      ins->data.op[0].p = var;
                      D.33101 = var->flags;
                      D.33102 = D.33101 | 16;
                      var->flags = D.33102;
                      ins->type = 5;
                      D.33103 = var->klass;
                      ins->klass = D.33103;
                      D.33104 = alloc_dreg (cfg, 5);
                      D.33105 = (int) D.33104;
                      ins->dreg = D.33105;
                      cfg->has_indirection = 1;
                      D.31089 = cfg->gsharedvt;
                      D.32043 = D.31089 != 0;
                      D.32044 = (long int) D.32043;
                      D.32045 = __builtin_expect (D.32044, 0);
                      if (D.32045 != 0) goto <D.33106>; else goto <D.33107>;
                      <D.33106>:
                      D.33108 = var->data.op[1].vtype;
                      D.33109 = mini_is_gsharedvt_variable_type (cfg, D.33108);
                      if (D.33109 != 0) goto <D.33110>; else goto <D.33111>;
                      <D.33110>:
                      handle_gsharedvt_ldaddr (cfg);
                      <D.33111>:
                      <D.33107>:
                      if (0 != 0) goto <D.33112>; else goto <D.33113>;
                      <D.33112>:
                      {
                        struct MonoInst * var1;
                        struct MonoInst * var2;

                        D.33115 = var->dreg;
                        D.33116 = D.33115 + 1;
                        D.33117 = (unsigned int) D.33116;
                        D.32058 = cfg->vreg_to_inst_len;
                        if (D.33117 < D.32058) goto <D.33118>; else goto <D.33119>;
                        <D.33118>:
                        D.32061 = cfg->vreg_to_inst;
                        D.33115 = var->dreg;
                        D.33120 = (sizetype) D.33115;
                        D.33121 = D.33120 + 1;
                        D.33122 = D.33121 * 8;
                        D.33123 = D.32061 + D.33122;
                        iftmp.110 = *D.33123;
                        goto <D.33124>;
                        <D.33119>:
                        iftmp.110 = 0B;
                        <D.33124>:
                        var1 = iftmp.110;
                        D.33115 = var->dreg;
                        D.33126 = D.33115 + 2;
                        D.33127 = (unsigned int) D.33126;
                        D.32058 = cfg->vreg_to_inst_len;
                        if (D.33127 < D.32058) goto <D.33128>; else goto <D.33129>;
                        <D.33128>:
                        D.32061 = cfg->vreg_to_inst;
                        D.33115 = var->dreg;
                        D.33120 = (sizetype) D.33115;
                        D.33130 = D.33120 + 2;
                        D.33131 = D.33130 * 8;
                        D.33132 = D.32061 + D.33131;
                        iftmp.111 = *D.33132;
                        goto <D.33133>;
                        <D.33129>:
                        iftmp.111 = 0B;
                        <D.33133>:
                        var2 = iftmp.111;
                        D.33134 = var1 == 0B;
                        D.33135 = (long int) D.33134;
                        D.33136 = __builtin_expect (D.33135, 0);
                        if (D.33136 != 0) goto <D.33137>; else goto <D.33138>;
                        <D.33137>:
                        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7827, "var1");
                        <D.33138>:
                        D.33139 = var2 == 0B;
                        D.33140 = (long int) D.33139;
                        D.33141 = __builtin_expect (D.33140, 0);
                        if (D.33141 != 0) goto <D.33142>; else goto <D.33143>;
                        <D.33142>:
                        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7827, "var2");
                        <D.33143>:
                        D.33144 = var1->flags;
                        D.33145 = D.33144 | 16;
                        var1->flags = D.33145;
                        D.33146 = var2->flags;
                        D.33147 = D.33146 | 16;
                        var2->flags = D.33147;
                      }
                      <D.33113>:
                    }
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    if (D.31191 != 0B) goto <D.33148>; else goto <D.33149>;
                    <D.33148>:
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    D.31191->next = ins;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    ins->prev = D.31191;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    goto <D.33150>;
                    <D.33149>:
                    bblock.113 = cfg->cbb;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    D.31191 = bblock.113->last_ins;
                    bblock.113->code = D.31191;
                    <D.33150>:
                    addr_reg = ins->dreg;
                    D.30941 = cfg->mempool;
                    ins = mono_mempool_alloc (D.30941, 80);
                    ins->data.op[1].const_val = 0;
                    D.31158 = ins->data.op[1].const_val;
                    ins->data.op[0].const_val = D.31158;
                    ins->prev = 0B;
                    D.31159 = ins->prev;
                    ins->next = D.31159;
                    ins->opcode = 374;
                    ins->flags = 0;
                    ins->type = 0;
                    ins->dreg = -1;
                    ins->sreg3 = -1;
                    D.31160 = ins->sreg3;
                    ins->sreg2 = D.31160;
                    D.31161 = ins->sreg2;
                    ins->sreg1 = D.31161;
                    D.31162 = cfg->ip;
                    ins->cil_code = D.31162;
                    ins->sreg1 = addr_reg;
                    D.33151 = args[4];
                    D.33152 = D.33151->dreg;
                    ins->dreg = D.33152;
                    ins->data.op[0].const_val = 0;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    if (D.31191 != 0B) goto <D.33153>; else goto <D.33154>;
                    <D.33153>:
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    D.31191->next = ins;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    ins->prev = D.31191;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    goto <D.33155>;
                    <D.33154>:
                    bblock.113 = cfg->cbb;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    D.31191 = bblock.113->last_ins;
                    bblock.113->code = D.31191;
                    <D.33155>:
                  }
                  goto <D.33156>;
                  <D.33085>:
                  D.30941 = cfg->mempool;
                  D.33157 = mono_mempool_alloc (D.30941, 80);
                  args[3] = D.33157;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->data.op[1].const_val = 0;
                  D.33159 = D.33158->data.op[1].const_val;
                  D.33158->data.op[0].const_val = D.33159;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->prev = 0B;
                  D.33160 = D.33158->prev;
                  D.33158->next = D.33160;
                  D.33158 = args[3];
                  D.33158->opcode = 362;
                  D.33158 = args[3];
                  D.33158->flags = 0;
                  D.33158 = args[3];
                  D.33158->type = 0;
                  D.33158 = args[3];
                  D.33158->dreg = -1;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->sreg3 = -1;
                  D.33161 = D.33158->sreg3;
                  D.33158->sreg2 = D.33161;
                  D.33162 = D.33158->sreg2;
                  D.33158->sreg1 = D.33162;
                  D.33158 = args[3];
                  D.31162 = cfg->ip;
                  D.33158->cil_code = D.31162;
                  D.33158 = args[3];
                  D.33158->data.op[0].const_val = 0;
                  D.33158 = args[3];
                  D.33158->type = 1;
                  D.33158 = args[3];
                  D.33163 = alloc_dreg (cfg, 1);
                  D.33164 = (int) D.33163;
                  D.33158->dreg = D.33164;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33165>; else goto <D.33166>;
                  <D.33165>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33158 = args[3];
                  D.31191->next = D.33158;
                  D.33158 = args[3];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33158->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33158 = args[3];
                  bblock.113->last_ins = D.33158;
                  goto <D.33167>;
                  <D.33166>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33158 = args[3];
                  bblock.113->last_ins = D.33158;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33167>:
                  D.30941 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30941, 80);
                  ins->data.op[1].const_val = 0;
                  D.31158 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.31158;
                  ins->prev = 0B;
                  D.31159 = ins->prev;
                  ins->next = D.31159;
                  ins->opcode = 374;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.31160 = ins->sreg3;
                  ins->sreg2 = D.31160;
                  D.31161 = ins->sreg2;
                  ins->sreg1 = D.31161;
                  D.31162 = cfg->ip;
                  ins->cil_code = D.31162;
                  D.33089 = sp + 8;
                  D.33090 = *D.33089;
                  D.33091 = D.33090->dreg;
                  ins->sreg1 = D.33091;
                  D.33151 = args[4];
                  D.33152 = D.33151->dreg;
                  ins->dreg = D.33152;
                  ins->data.op[0].const_val = 0;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33168>; else goto <D.33169>;
                  <D.33168>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = ins;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  ins->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  goto <D.33170>;
                  <D.33169>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33170>:
                  <D.33156>:
                  goto <D.33071>;
                  <D.33070>:
                  D.30941 = cfg->mempool;
                  D.33171 = mono_mempool_alloc (D.30941, 80);
                  args[3] = D.33171;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->data.op[1].const_val = 0;
                  D.33159 = D.33158->data.op[1].const_val;
                  D.33158->data.op[0].const_val = D.33159;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->prev = 0B;
                  D.33160 = D.33158->prev;
                  D.33158->next = D.33160;
                  D.33158 = args[3];
                  D.33158->opcode = 362;
                  D.33158 = args[3];
                  D.33158->flags = 0;
                  D.33158 = args[3];
                  D.33158->type = 0;
                  D.33158 = args[3];
                  D.33158->dreg = -1;
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158 = args[3];
                  D.33158->sreg3 = -1;
                  D.33161 = D.33158->sreg3;
                  D.33158->sreg2 = D.33161;
                  D.33162 = D.33158->sreg2;
                  D.33158->sreg1 = D.33162;
                  D.33158 = args[3];
                  D.31162 = cfg->ip;
                  D.33158->cil_code = D.31162;
                  D.33158 = args[3];
                  D.33158->data.op[0].const_val = 0;
                  D.33158 = args[3];
                  D.33158->type = 1;
                  D.33158 = args[3];
                  D.33172 = alloc_dreg (cfg, 1);
                  D.33173 = (int) D.33172;
                  D.33158->dreg = D.33173;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33174>; else goto <D.33175>;
                  <D.33174>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33158 = args[3];
                  D.31191->next = D.33158;
                  D.33158 = args[3];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33158->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33158 = args[3];
                  bblock.113->last_ins = D.33158;
                  goto <D.33176>;
                  <D.33175>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33158 = args[3];
                  bblock.113->last_ins = D.33158;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33176>:
                  D.30941 = cfg->mempool;
                  D.33177 = mono_mempool_alloc (D.30941, 80);
                  args[4] = D.33177;
                  D.33151 = args[4];
                  D.33151 = args[4];
                  D.33151->data.op[1].const_val = 0;
                  D.33178 = D.33151->data.op[1].const_val;
                  D.33151->data.op[0].const_val = D.33178;
                  D.33151 = args[4];
                  D.33151 = args[4];
                  D.33151->prev = 0B;
                  D.33179 = D.33151->prev;
                  D.33151->next = D.33179;
                  D.33151 = args[4];
                  D.33151->opcode = 362;
                  D.33151 = args[4];
                  D.33151->flags = 0;
                  D.33151 = args[4];
                  D.33151->type = 0;
                  D.33151 = args[4];
                  D.33151->dreg = -1;
                  D.33151 = args[4];
                  D.33151 = args[4];
                  D.33151 = args[4];
                  D.33151->sreg3 = -1;
                  D.33180 = D.33151->sreg3;
                  D.33151->sreg2 = D.33180;
                  D.33181 = D.33151->sreg2;
                  D.33151->sreg1 = D.33181;
                  D.33151 = args[4];
                  D.31162 = cfg->ip;
                  D.33151->cil_code = D.31162;
                  D.33151 = args[4];
                  D.33151->data.op[0].const_val = 0;
                  D.33151 = args[4];
                  D.33151->type = 1;
                  D.33151 = args[4];
                  D.33182 = alloc_dreg (cfg, 1);
                  D.33183 = (int) D.33182;
                  D.33151->dreg = D.33183;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33184>; else goto <D.33185>;
                  <D.33184>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33151 = args[4];
                  D.31191->next = D.33151;
                  D.33151 = args[4];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33151->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33151 = args[4];
                  bblock.113->last_ins = D.33151;
                  goto <D.33186>;
                  <D.33185>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33151 = args[4];
                  bblock.113->last_ins = D.33151;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33186>:
                  <D.33071>:
                  ins = mono_emit_jit_icall (cfg, mono_gsharedvt_constrained_call, &args);
                  emit_widen = 0;
                  D.32915 = fsig->ret;
                  D.33187 = mini_is_gsharedvt_type (cfg, D.32915);
                  if (D.33187 != 0) goto <D.33188>; else goto <D.33189>;
                  <D.33188>:
                  D.32915 = fsig->ret;
                  D.33190 = mono_class_from_mono_type (D.32915);
                  ins = handle_unbox_gsharedvt (cfg, D.33190, ins, &bblock);
                  goto <D.33191>;
                  <D.33189>:
                  D.32915 = fsig->ret;
                  D.33021 = BIT_FIELD_REF <*D.32915, 64, 64>;
                  D.33022 = D.33021 & 1073741824;
                  if (D.33022 == 0) goto <D.33194>; else goto <D.33195>;
                  <D.33194>:
                  D.32915 = fsig->ret;
                  D.33024 = D.32915->type;
                  D.33025 = D.33024 + 254;
                  if (D.33025 <= 11) goto <D.33192>; else goto <D.33196>;
                  <D.33196>:
                  D.32915 = fsig->ret;
                  D.33024 = D.32915->type;
                  D.33027 = D.33024 + 232;
                  if (D.33027 <= 1) goto <D.33192>; else goto <D.33193>;
                  <D.33192>:
                  {
                    struct MonoInst * add;

                    D.30941 = cfg->mempool;
                    add = mono_mempool_alloc (D.30941, 80);
                    add->data.op[1].const_val = 0;
                    D.33197 = add->data.op[1].const_val;
                    add->data.op[0].const_val = D.33197;
                    add->prev = 0B;
                    D.33198 = add->prev;
                    add->next = D.33198;
                    add->opcode = 429;
                    add->flags = 0;
                    add->type = 0;
                    add->dreg = -1;
                    add->sreg3 = -1;
                    D.33199 = add->sreg3;
                    add->sreg2 = D.33199;
                    D.33200 = add->sreg2;
                    add->sreg1 = D.33200;
                    D.31162 = cfg->ip;
                    add->cil_code = D.31162;
                    D.33201 = alloc_dreg (cfg, 5);
                    D.33202 = (int) D.33201;
                    add->dreg = D.33202;
                    D.31356 = ins->dreg;
                    add->sreg1 = D.31356;
                    add->data.op[1].const_val = 16;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    if (D.31191 != 0B) goto <D.33203>; else goto <D.33204>;
                    <D.33203>:
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    D.31191->next = add;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    add->prev = D.31191;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = add;
                    goto <D.33205>;
                    <D.33204>:
                    bblock.113 = cfg->cbb;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = add;
                    D.31191 = bblock.113->last_ins;
                    bblock.113->code = D.31191;
                    <D.33205>:
                    D.30941 = cfg->mempool;
                    ins = mono_mempool_alloc (D.30941, 80);
                    ins->data.op[1].const_val = 0;
                    D.31158 = ins->data.op[1].const_val;
                    ins->data.op[0].const_val = D.31158;
                    ins->prev = 0B;
                    D.31159 = ins->prev;
                    ins->next = D.31159;
                    D.32915 = fsig->ret;
                    D.33206 = mono_type_to_load_membase (cfg, D.32915);
                    D.33207 = (short unsigned int) D.33206;
                    ins->opcode = D.33207;
                    ins->flags = 0;
                    ins->type = 0;
                    ins->dreg = -1;
                    ins->sreg3 = -1;
                    D.31160 = ins->sreg3;
                    ins->sreg2 = D.31160;
                    D.31161 = ins->sreg2;
                    ins->sreg1 = D.31161;
                    D.31162 = cfg->ip;
                    ins->cil_code = D.31162;
                    ins->dreg = 0;
                    D.33208 = add->dreg;
                    ins->sreg1 = D.33208;
                    ins->data.op[0].const_val = 0;
                    ins->type = 1;
                    D.32915 = fsig->ret;
                    type_to_eval_stack_type (cfg, D.32915, ins);
                    D.31705 = ins->type;
                    D.31706 = (<unnamed type>) D.31705;
                    D.33209 = alloc_dreg (cfg, D.31706);
                    D.33210 = (int) D.33209;
                    ins->dreg = D.33210;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    if (D.31191 != 0B) goto <D.33211>; else goto <D.33212>;
                    <D.33211>:
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    D.31191->next = ins;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    ins->prev = D.31191;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    goto <D.33213>;
                    <D.33212>:
                    bblock.113 = cfg->cbb;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = ins;
                    D.31191 = bblock.113->last_ins;
                    bblock.113->code = D.31191;
                    <D.33213>:
                  }
                  <D.33193>:
                  <D.33195>:
                  <D.33191>:
                  goto call_end;
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            <D.33012>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.33214>; else goto <D.33215>;
            <D.33214>:
            D.30878 = method->klass;
            D.32629 = D.30878->name_space;
            D.30878 = method->klass;
            D.32630 = D.30878->name;
            D.32631 = method->name;
            D.32632 = method->signature;
            D.32633 = D.32632->param_count;
            D.32634 = (int) D.32633;
            D.31838 = *ip;
            D.31839 = (int) D.31838;
            D.33216 = mono_opcode_name (D.31839);
            D.33217 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.33216, "method-to-ir.c", 7857);
            cfg->exception_message = D.33217;
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.33218>; else goto <D.33219>;
            <D.33218>:
            D.32639 = cfg->exception_message;
            printf ("%s\n", D.32639);
            <D.33219>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.33215>:
            <D.33003>:
            <D.32995>:
            <D.32993>:
            D.32998 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32999 = D.32998 & 8;
            if (D.32999 != 0) goto <D.33223>; else goto <D.33220>;
            <D.33223>:
            D.32828 = cmethod->klass;
            D.32996 = mono_defaults.object_class;
            if (D.32828 == D.32996) goto <D.33221>; else goto <D.33224>;
            <D.33224>:
            D.32828 = cmethod->klass;
            D.33225 = mono_defaults.enum_class;
            D.33226 = D.33225->parent;
            if (D.32828 == D.33226) goto <D.33221>; else goto <D.33227>;
            <D.33227>:
            D.32828 = cmethod->klass;
            D.33225 = mono_defaults.enum_class;
            if (D.32828 == D.33225) goto <D.33221>; else goto <D.33220>;
            <D.33221>:
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            D.33228 = &constrained_call->byval_arg;
            D.33229 = mono_type_to_load_membase (cfg, D.33228);
            D.33230 = (short unsigned int) D.33229;
            ins->opcode = D.33230;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = 0;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ins->sreg1 = D.32139;
            ins->data.op[0].const_val = 0;
            ins->type = 1;
            D.33228 = &constrained_call->byval_arg;
            type_to_eval_stack_type (cfg, D.33228, ins);
            D.31705 = ins->type;
            D.31706 = (<unnamed type>) D.31705;
            D.33231 = alloc_dreg (cfg, D.31706);
            D.33232 = (int) D.33231;
            ins->dreg = D.33232;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.33233>; else goto <D.33234>;
            <D.33233>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.33235>;
            <D.33234>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.33235>:
            ins->klass = constrained_call;
            D.33236 = mono_class_check_context_used (constrained_call);
            D.33237 = handle_box (cfg, ins, constrained_call, D.33236, &bblock);
            *sp = D.33237;
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.33238>;
            <D.33238>:
            goto <D.33222>;
            <D.33220>:
            D.32998 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32999 = D.32998 & 8;
            if (D.32999 == 0) goto <D.33239>; else goto <D.33240>;
            <D.33239>:
            {
              int dreg;

              D.33241 = alloc_ireg_ref (cfg);
              dreg = (int) D.33241;
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 388;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              ins->dreg = dreg;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              ins->sreg1 = D.32139;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33242>; else goto <D.33243>;
              <D.33242>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.33244>;
              <D.33243>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33244>:
              ins->type = 6;
              *sp = ins;
            }
            goto <D.33245>;
            <D.33240>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32830 = D.32829 & 8;
            if (D.32830 != 0) goto <D.33246>; else goto <D.33247>;
            <D.33246>:
            goto <D.33248>;
            <D.33247>:
            {
              int ioffset;
              int slot;

              mono_class_setup_vtable (constrained_call);
              if (constrained_call == 0B) goto <D.33249>; else goto <D.33251>;
              <D.33251>:
              D.33252 = constrained_call->exception_type;
              if (D.33252 != 0) goto <D.33249>; else goto <D.33250>;
              <D.33249>:
              cfg->exception_ptr = constrained_call;
              D.33253 = mini_get_debug_options ();
              D.33254 = D.33253->break_on_unverified;
              if (D.33254 != 0) goto <D.33255>; else goto load_error;
              <D.33255>:
              raise (5);
              <D.33250>:
              D.32828 = cmethod->klass;
              ioffset = mono_class_interface_offset (constrained_call, D.32828);
              if (ioffset == -1) goto <D.33256>; else goto <D.33257>;
              <D.33256>:
              D.33258 = mini_get_debug_options ();
              D.33259 = D.33258->break_on_unverified;
              if (D.33259 != 0) goto <D.33260>; else goto <D.33261>;
              <D.33260>:
              raise (5);
              goto <D.33262>;
              <D.33261>:
              cfg->exception_ptr = constrained_call;
              goto load_error;
              <D.33262>:
              <D.33257>:
              slot = mono_method_get_vtable_slot (cmethod);
              if (slot == -1) goto <D.33263>; else goto <D.33264>;
              <D.33263>:
              D.33265 = mini_get_debug_options ();
              D.33266 = D.33265->break_on_unverified;
              if (D.33266 != 0) goto <D.33267>; else goto <D.33268>;
              <D.33267>:
              raise (5);
              goto <D.33269>;
              <D.33268>:
              D.32828 = cmethod->klass;
              cfg->exception_ptr = D.32828;
              goto load_error;
              <D.33269>:
              <D.33264>:
              D.33270 = constrained_call->vtable;
              D.33271 = ioffset + slot;
              D.33272 = (long unsigned int) D.33271;
              D.33273 = D.33272 * 8;
              D.33274 = D.33270 + D.33273;
              cmethod = *D.33274;
              D.32828 = cmethod->klass;
              D.33225 = mono_defaults.enum_class;
              if (D.32828 == D.33225) goto <D.33275>; else goto <D.33276>;
              <D.33275>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              D.33228 = &constrained_call->byval_arg;
              D.33277 = mono_type_to_load_membase (cfg, D.33228);
              D.33278 = (short unsigned int) D.33277;
              ins->opcode = D.33278;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              ins->dreg = 0;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              ins->sreg1 = D.32139;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              D.33228 = &constrained_call->byval_arg;
              type_to_eval_stack_type (cfg, D.33228, ins);
              D.31705 = ins->type;
              D.31706 = (<unnamed type>) D.31705;
              D.33279 = alloc_dreg (cfg, D.31706);
              D.33280 = (int) D.33279;
              ins->dreg = D.33280;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33281>; else goto <D.33282>;
              <D.33281>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.33283>;
              <D.33282>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33283>:
              ins->klass = constrained_call;
              D.33284 = mono_class_check_context_used (constrained_call);
              D.33285 = handle_box (cfg, ins, constrained_call, D.33284, &bblock);
              *sp = D.33285;
              D.31510 = cfg->exception_type;
              if (D.31510 != 0) goto exception_exit; else goto <D.33286>;
              <D.33286>:
              <D.33276>:
            }
            <D.33248>:
            virtual = 0;
            <D.33245>:
            <D.33222>:
            constrained_call = 0B;
            <D.32990>:
            if (calli == 0) goto <D.33287>; else goto <D.33288>;
            <D.33287>:
            D.33289 = check_call_signature (cfg, fsig, sp);
            if (D.33289 != 0) goto <D.33290>; else goto <D.33291>;
            <D.33290>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.33292>; else goto <D.33293>;
            <D.33292>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.33294>; else goto <D.33295>;
            <D.33294>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.33295>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.33293>:
            D.33296 = mini_get_debug_options ();
            D.33297 = D.33296->break_on_unverified;
            if (D.33297 != 0) goto <D.33298>; else goto unverified;
            <D.33298>:
            raise (5);
            <D.33291>:
            <D.33288>:
            if (cmethod != 0B) goto <D.33299>; else goto <D.33300>;
            <D.33299>:
            D.32828 = cmethod->klass;
            D.33301 = D.32828->parent;
            D.33302 = mono_defaults.multicastdelegate_class;
            if (D.33301 == D.33302) goto <D.33303>; else goto <D.33304>;
            <D.33303>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 6;
              if (__s2_len <= 3) goto <D.33306>; else goto <D.33307>;
              <D.33306>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = cmethod->name;
                D.33308 = "Invoke";
                D.33309 = MEM[(const unsigned char *)D.33308];
                D.33310 = (int) D.33309;
                D.33311 = *__s2;
                D.33312 = (int) D.33311;
                __result = D.33310 - D.33312;
                {
                  if (__s2_len != 0) goto <D.33313>; else goto <D.33314>;
                  <D.33313>:
                  if (__result == 0) goto <D.33315>; else goto <D.33316>;
                  <D.33315>:
                  D.33317 = &MEM[(void *)"Invoke" + 1B];
                  D.33318 = *D.33317;
                  D.33319 = (int) D.33318;
                  D.33320 = __s2 + 1;
                  D.33321 = *D.33320;
                  D.33322 = (int) D.33321;
                  __result = D.33319 - D.33322;
                  if (__s2_len > 1) goto <D.33323>; else goto <D.33324>;
                  <D.33323>:
                  if (__result == 0) goto <D.33325>; else goto <D.33326>;
                  <D.33325>:
                  D.33327 = &MEM[(void *)"Invoke" + 2B];
                  D.33328 = *D.33327;
                  D.33329 = (int) D.33328;
                  D.33330 = __s2 + 2;
                  D.33331 = *D.33330;
                  D.33332 = (int) D.33331;
                  __result = D.33329 - D.33332;
                  if (__s2_len > 2) goto <D.33333>; else goto <D.33334>;
                  <D.33333>:
                  if (__result == 0) goto <D.33335>; else goto <D.33336>;
                  <D.33335>:
                  D.33337 = &MEM[(void *)"Invoke" + 3B];
                  D.33338 = *D.33337;
                  D.33339 = (int) D.33338;
                  D.33340 = __s2 + 3;
                  D.33341 = *D.33340;
                  D.33342 = (int) D.33341;
                  __result = D.33339 - D.33342;
                  <D.33336>:
                  <D.33334>:
                  <D.33326>:
                  <D.33324>:
                  <D.33316>:
                  <D.33314>:
                }
                D.27981 = __result;
              }
              iftmp.112 = -D.27981;
              goto <D.33343>;
              <D.33307>:
              D.33344 = cmethod->name;
              iftmp.112 = __builtin_strcmp (D.33344, "Invoke");
              <D.33343>:
              D.27982 = iftmp.112;
            }
            if (D.27982 == 0) goto <D.33345>; else goto <D.33346>;
            <D.33345>:
            delegate_invoke = 1;
            <D.33346>:
            <D.33304>:
            <D.33300>:
            if (cmethod != 0B) goto <D.33347>; else goto <D.33348>;
            <D.33347>:
            D.31334 = cfg->opt;
            D.33349 = D.31334 & 2048;
            if (D.33349 != 0) goto <D.33350>; else goto <D.33351>;
            <D.33350>:
            ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp);
            if (ins != 0B) goto <D.33352>; else goto <D.33353>;
            <D.33352>:
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            D.32915 = fsig->ret;
            D.33354 = mono_type_is_void (D.32915);
            if (D.33354 == 0) goto <D.33355>; else goto <D.33356>;
            <D.33355>:
            D.32915 = fsig->ret;
            type_to_eval_stack_type (cfg, D.32915, ins);
            emit_widen = 0;
            <D.33356>:
            goto call_end;
            <D.33353>:
            <D.33351>:
            <D.33348>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 != 0B) goto <D.33357>; else goto <D.33358>;
            <D.33357>:
            if (cmethod != 0B) goto <D.33359>; else goto <D.33360>;
            <D.33359>:
            D.32828 = cmethod->klass;
            D.30878 = method->klass;
            if (D.32828 != D.30878) goto <D.33361>; else goto <D.33362>;
            <D.33361>:
            D.32828 = cmethod->klass;
            D.33363 = D.32828->generic_class;
            if (D.33363 != 0B) goto <D.33364>; else goto <D.33365>;
            <D.33364>:
            D.33366 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.33366 != 0) goto <D.33367>; else goto <D.33368>;
            <D.33367>:
            D.32828 = cmethod->klass;
            D.33369 = mono_class_needs_cctor_run (D.32828, method);
            if (D.33369 != 0) goto <D.33370>; else goto <D.33371>;
            <D.33370>:
            D.32828 = cmethod->klass;
            emit_generic_class_init (cfg, D.32828);
            D.32828 = cmethod->klass;
            if (D.32828 == 0B) goto <D.33372>; else goto <D.33374>;
            <D.33374>:
            D.32828 = cmethod->klass;
            D.33375 = D.32828->exception_type;
            if (D.33375 != 0) goto <D.33372>; else goto <D.33373>;
            <D.33372>:
            D.32828 = cmethod->klass;
            cfg->exception_ptr = D.32828;
            D.33376 = mini_get_debug_options ();
            D.33377 = D.33376->break_on_unverified;
            if (D.33377 != 0) goto <D.33378>; else goto load_error;
            <D.33378>:
            raise (5);
            <D.33373>:
            <D.33371>:
            <D.33368>:
            <D.33365>:
            <D.33362>:
            <D.33360>:
            <D.33358>:
            if (cmethod != 0B) goto <D.33379>; else goto <D.33380>;
            <D.33379>:
            check_method_sharing (cfg, cmethod, &pass_vtable, &pass_mrgctx);
            <D.33380>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 != 0B) goto <D.33381>; else goto <D.33382>;
            <D.33381>:
            if (cmethod != 0B) goto <D.33383>; else goto <D.33384>;
            <D.33383>:
            {
              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.33385>; else goto <D.33386>;
              <D.33385>:
              D.32828 = cmethod->klass;
              D.33007 = D.32828->flags;
              D.33008 = D.33007 & 32;
              if (D.33008 != 0) goto <D.33387>; else goto <D.33388>;
              <D.33387>:
              if (cmethod_context == 0B) goto <D.33389>; else goto <D.33391>;
              <D.33391>:
              D.33392 = cmethod_context->method_inst;
              if (D.33392 == 0B) goto <D.33389>; else goto <D.33390>;
              <D.33389>:
              pass_imt_from_rgctx = 1;
              <D.33390>:
              <D.33388>:
              <D.33386>:
              if (context_used != 0) goto <D.33395>; else goto <D.33396>;
              <D.33395>:
              D.31241 = method->flags;
              D.31242 = (int) D.31241;
              D.31243 = D.31242 & 16;
              if (D.31243 != 0) goto <D.33393>; else goto <D.33397>;
              <D.33397>:
              D.30878 = method->klass;
              D.31030 = BIT_FIELD_REF <*D.30878, 64, 256>;
              D.31031 = D.31030 & 8;
              if (D.31031 != 0) goto <D.33393>; else goto <D.33394>;
              <D.33393>:
              mono_get_vtable_var (cfg);
              <D.33394>:
              <D.33396>:
            }
            <D.33384>:
            <D.33382>:
            pass_vtable.114 = pass_vtable;
            if (pass_vtable.114 != 0) goto <D.33399>; else goto <D.33400>;
            <D.33399>:
            if (context_used != 0) goto <D.33401>; else goto <D.33402>;
            <D.33401>:
            D.32828 = cmethod->klass;
            vtable_arg = emit_get_rgctx_klass (cfg, context_used, D.32828, 2);
            goto <D.33403>;
            <D.33402>:
            {
              struct MonoVTable * vtable;

              D.30966 = cfg->domain;
              D.32828 = cmethod->klass;
              vtable = mono_class_vtable (D.30966, D.32828);
              D.32828 = cmethod->klass;
              if (D.32828 == 0B) goto <D.33404>; else goto <D.33406>;
              <D.33406>:
              D.32828 = cmethod->klass;
              D.33375 = D.32828->exception_type;
              if (D.33375 != 0) goto <D.33404>; else goto <D.33405>;
              <D.33404>:
              D.32828 = cmethod->klass;
              cfg->exception_ptr = D.32828;
              D.33407 = mini_get_debug_options ();
              D.33408 = D.33407->break_on_unverified;
              if (D.33408 != 0) goto <D.33409>; else goto load_error;
              <D.33409>:
              raise (5);
              <D.33405>:
              D.30941 = cfg->mempool;
              vtable_arg = mono_mempool_alloc (D.30941, 80);
              vtable_arg->data.op[1].const_val = 0;
              D.33410 = vtable_arg->data.op[1].const_val;
              vtable_arg->data.op[0].const_val = D.33410;
              vtable_arg->prev = 0B;
              D.33411 = vtable_arg->prev;
              vtable_arg->next = D.33411;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.33413>; else goto <D.33414>;
              <D.33413>:
              iftmp.115 = 734;
              goto <D.33415>;
              <D.33414>:
              iftmp.115 = 363;
              <D.33415>:
              vtable_arg->opcode = iftmp.115;
              vtable_arg->flags = 0;
              vtable_arg->type = 0;
              vtable_arg->dreg = -1;
              vtable_arg->sreg3 = -1;
              D.33416 = vtable_arg->sreg3;
              vtable_arg->sreg2 = D.33416;
              D.33417 = vtable_arg->sreg2;
              vtable_arg->sreg1 = D.33417;
              D.31162 = cfg->ip;
              vtable_arg->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.33418>; else goto <D.33419>;
              <D.33418>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.33420 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.33420;
                group->prev = 0B;
                D.33421 = group->prev;
                group->next = D.33421;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.33422 = group->sreg3;
                group->sreg2 = D.33422;
                D.33423 = group->sreg2;
                group->sreg1 = D.33423;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.31337 = D.31336 & 274877906944;
                if (D.31337 != 0) goto <D.33425>; else goto <D.33426>;
                <D.33425>:
                iftmp.116 = vtable->klass;
                goto <D.33427>;
                <D.33426>:
                iftmp.116 = vtable;
                <D.33427>:
                group->data.op[0].src = iftmp.116;
                group->data.op[1].src = 14B;
                D.33428 = got_loc->dreg;
                vtable_arg->sreg1 = D.33428;
                vtable_arg->data.op[1].p = group;
              }
              goto <D.33429>;
              <D.33419>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.33431>; else goto <D.33432>;
              <D.33431>:
              iftmp.117 = vtable->klass;
              goto <D.33433>;
              <D.33432>:
              iftmp.117 = vtable;
              <D.33433>:
              vtable_arg->data.op[0].p = iftmp.117;
              vtable_arg->data.op[1].src = 14B;
              <D.33429>:
              vtable_arg->type = 3;
              D.33434 = alloc_dreg (cfg, 3);
              D.33435 = (int) D.33434;
              vtable_arg->dreg = D.33435;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33436>; else goto <D.33437>;
              <D.33436>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = vtable_arg;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              vtable_arg->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = vtable_arg;
              goto <D.33438>;
              <D.33437>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = vtable_arg;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33438>:
            }
            <D.33403>:
            <D.33400>:
            pass_mrgctx.118 = pass_mrgctx;
            if (pass_mrgctx.118 != 0) goto <D.33440>; else goto <D.33441>;
            <D.33440>:
            D.33442 = vtable_arg != 0B;
            D.33443 = (long int) D.33442;
            D.33444 = __builtin_expect (D.33443, 0);
            if (D.33444 != 0) goto <D.33445>; else goto <D.33446>;
            <D.33445>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7986, "!vtable_arg");
            <D.33446>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 == 0) goto <D.33447>; else goto <D.33448>;
            <D.33447>:
            D.32828 = cmethod->klass;
            mono_class_setup_vtable (D.32828);
            D.32828 = cmethod->klass;
            if (D.32828 == 0B) goto <D.33449>; else goto <D.33451>;
            <D.33451>:
            D.32828 = cmethod->klass;
            D.33375 = D.32828->exception_type;
            if (D.33375 != 0) goto <D.33449>; else goto <D.33450>;
            <D.33449>:
            D.32828 = cmethod->klass;
            cfg->exception_ptr = D.32828;
            D.33452 = mini_get_debug_options ();
            D.33453 = D.33452->break_on_unverified;
            if (D.33453 != 0) goto <D.33454>; else goto load_error;
            <D.33454>:
            raise (5);
            <D.33450>:
            <D.33448>:
            vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 8);
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33457 = D.32865 & 64;
            if (D.33457 == 0) goto <D.33455>; else goto <D.33458>;
            <D.33458>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33459 = D.32865 & 32;
            if (D.33459 != 0) goto <D.33455>; else goto <D.33460>;
            <D.33460>:
            D.32828 = cmethod->klass;
            if (D.32828 != 0B) goto <D.33461>; else goto <D.33456>;
            <D.33461>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33462 = D.33007 & 256;
            if (D.33462 != 0) goto <D.33455>; else goto <D.33456>;
            <D.33455>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32871 = D.32829 & 4194304;
            if (D.32871 == 0) goto <D.33463>; else goto <D.33464>;
            <D.33463>:
            if (virtual != 0) goto <D.33465>; else goto <D.33466>;
            <D.33465>:
            check_this = 1;
            <D.33466>:
            virtual = 0;
            <D.33464>:
            <D.33456>:
            <D.33441>:
            if (pass_imt_from_rgctx != 0) goto <D.33467>; else goto <D.33468>;
            <D.33467>:
            pass_vtable.114 = pass_vtable;
            D.33469 = pass_vtable.114 != 0;
            D.33470 = (long int) D.33469;
            D.33471 = __builtin_expect (D.33470, 0);
            if (D.33471 != 0) goto <D.33472>; else goto <D.33473>;
            <D.33472>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8010, "!pass_vtable");
            <D.33473>:
            D.33474 = cmethod == 0B;
            D.33475 = (long int) D.33474;
            D.33476 = __builtin_expect (D.33475, 0);
            if (D.33476 != 0) goto <D.33477>; else goto <D.33478>;
            <D.33477>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8011, "cmethod");
            <D.33478>:
            imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            <D.33468>:
            if (check_this != 0) goto <D.33479>; else goto <D.33480>;
            <D.33479>:
            D.31372 = cfg->flags;
            D.31586 = D.31372 | 128;
            cfg->flags = D.31586;
            D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.31587 = D.30929 & 64;
            if (D.31587 != 0) goto <D.33481>; else goto <D.33482>;
            <D.33481>:
            D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.31587 = D.30929 & 64;
            if (D.31587 != 0) goto <D.33483>; else goto <D.33484>;
            <D.33483>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.33485 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33485;
              inst->prev = 0B;
              D.33486 = inst->prev;
              inst->next = D.33486;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33487 = inst->sreg3;
              inst->sreg2 = D.33487;
              D.33488 = inst->sreg2;
              inst->sreg1 = D.33488;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              inst->data.op[1].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33489>; else goto <D.33490>;
              <D.33489>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.33491>;
              <D.33490>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33491>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.33492 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33492;
              inst->prev = 0B;
              D.33493 = inst->prev;
              inst->next = D.33493;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33494 = inst->sreg3;
              inst->sreg2 = D.33494;
              D.33495 = inst->sreg2;
              inst->sreg1 = D.33495;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->data.op[1].p = "NullReferenceException";
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33496>; else goto <D.33497>;
              <D.33496>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.33498>;
              <D.33497>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33498>:
            }
            goto <D.33499>;
            <D.33484>:
            <D.33499>:
            goto <D.33500>;
            <D.33482>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.33501 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33501;
              inst->prev = 0B;
              D.33502 = inst->prev;
              inst->next = D.33502;
              inst->opcode = 340;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33503 = inst->sreg3;
              inst->sreg2 = D.33503;
              D.33504 = inst->sreg2;
              inst->sreg1 = D.33504;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33505>; else goto <D.33506>;
              <D.33505>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.33507>;
              <D.33506>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33507>:
            }
            <D.33500>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.33508 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33508;
              inst->prev = 0B;
              D.33509 = inst->prev;
              inst->next = D.33509;
              inst->opcode = 799;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33510 = inst->sreg3;
              inst->sreg2 = D.33510;
              D.33511 = inst->sreg2;
              inst->sreg1 = D.33511;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33512>; else goto <D.33513>;
              <D.33512>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.33514>;
              <D.33513>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33514>:
            }
            <D.33480>:
            if (cmethod != 0B) goto <D.33520>; else goto <D.33521>;
            <D.33520>:
            if (virtual != 0) goto <D.33522>; else goto <D.33523>;
            <D.33522>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33457 = D.32865 & 64;
            if (D.33457 != 0) goto <D.33524>; else goto <D.33525>;
            <D.33524>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33459 = D.32865 & 32;
            if (D.33459 == 0) goto <D.33526>; else goto <D.33517>;
            <D.33526>:
            D.32828 = cmethod->klass;
            if (D.32828 == 0B) goto <D.33518>; else goto <D.33527>;
            <D.33527>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33462 = D.33007 & 256;
            if (D.33462 == 0) goto <D.33518>; else goto <D.33517>;
            <D.33517>:
            D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.33528 = D.32948 & 124;
            if (D.33528 == 36) goto <D.33518>; else goto <D.33519>;
            <D.33518>:
            D.33529 = fsig->generic_param_count;
            if (D.33529 != 0) goto <D.33530>; else goto <D.33531>;
            <D.33530>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 == 0) goto <D.33515>; else goto <D.33532>;
            <D.33532>:
            D.33533 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.33533 == 0) goto <D.33515>; else goto <D.33516>;
            <D.33515>:
            {
              struct MonoInst * this_temp;
              struct MonoInst * this_arg_temp;
              struct MonoInst * store;
              struct MonoInst * iargs[4];
              gboolean use_imt;

              try
                {
                  use_imt = 0;
                  D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.33534 = D.32764 & 144115188075855872;
                  D.33535 = D.33534 == 0;
                  D.33536 = (long int) D.33535;
                  D.33537 = __builtin_expect (D.33536, 0);
                  if (D.33537 != 0) goto <D.33538>; else goto <D.33539>;
                  <D.33538>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8031, "fsig->is_inflated");
                  <D.33539>:
                  D.30911 = cfg->method;
                  if (D.30911 != method) goto <D.33540>; else goto <D.33541>;
                  <D.33540>:
                  D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30884 = D.30883 & 124;
                  if (D.30884 == 0) goto <D.33542>; else goto <D.33543>;
                  <D.33542>:
                  D.31021 = cfg->verbose_level;
                  if (D.31021 > 1) goto <D.33544>; else goto <D.33545>;
                  <D.33544>:
                  printf ("inline failed: %s\n", "virtual generic call");
                  <D.33545>:
                  goto inline_failure;
                  <D.33543>:
                  <D.33541>:
                  D.31089 = cfg->gsharedvt;
                  if (D.31089 != 0) goto <D.33546>; else goto <D.33547>;
                  <D.33546>:
                  D.33548 = mini_is_gsharedvt_signature (cfg, fsig);
                  if (D.33548 != 0) goto <D.33549>; else goto <D.33550>;
                  <D.33549>:
                  D.31089 = cfg->gsharedvt;
                  if (D.31089 != 0) goto <D.33551>; else goto <D.33552>;
                  <D.33551>:
                  D.30878 = method->klass;
                  D.32629 = D.30878->name_space;
                  D.30878 = method->klass;
                  D.32630 = D.30878->name;
                  D.32631 = method->name;
                  D.32632 = method->signature;
                  D.32633 = D.32632->param_count;
                  D.32634 = (int) D.32633;
                  D.31838 = *ip;
                  D.31839 = (int) D.31838;
                  D.33553 = mono_opcode_name (D.31839);
                  D.33554 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.33553, "method-to-ir.c", 8037);
                  cfg->exception_message = D.33554;
                  D.31021 = cfg->verbose_level;
                  if (D.31021 > 1) goto <D.33555>; else goto <D.33556>;
                  <D.33555>:
                  D.32639 = cfg->exception_message;
                  printf ("%s\n", D.32639);
                  <D.33556>:
                  mono_cfg_set_exception (cfg, 11);
                  goto exception_exit;
                  <D.33552>:
                  <D.33550>:
                  <D.33547>:
                  D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
                  D.33528 = D.32948 & 124;
                  if (D.33528 == 0) goto <D.33557>; else goto <D.33558>;
                  <D.33557>:
                  mono_use_imt.119 = mono_use_imt;
                  if (mono_use_imt.119 != 0) goto <D.33560>; else goto <D.33561>;
                  <D.33560>:
                  use_imt = 1;
                  <D.33561>:
                  <D.33558>:
                  if (use_imt != 0) goto <D.33562>; else goto <D.33563>;
                  <D.33562>:
                  D.33564 = imt_arg != 0B;
                  D.33565 = (long int) D.33564;
                  D.33566 = __builtin_expect (D.33565, 0);
                  if (D.33566 != 0) goto <D.33567>; else goto <D.33568>;
                  <D.33567>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8045, "!imt_arg");
                  <D.33568>:
                  if (context_used == 0) goto <D.33569>; else goto <D.33570>;
                  <D.33569>:
                  D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
                  D.33571 = D.32948 & 4096;
                  D.33572 = D.33571 == 0;
                  D.33573 = (long int) D.33572;
                  D.33574 = __builtin_expect (D.33573, 0);
                  if (D.33574 != 0) goto <D.33575>; else goto <D.33576>;
                  <D.33575>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8047, "cmethod->is_inflated");
                  <D.33576>:
                  <D.33570>:
                  imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
                  D.31957 = *sp;
                  ins = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, D.31957, imt_arg, 0B);
                  goto <D.33577>;
                  <D.33563>:
                  D.31957 = *sp;
                  D.33578 = type_from_stack_type (D.31957);
                  this_temp = mono_compile_create_var (cfg, D.33578, 329);
                  D.30941 = cfg->mempool;
                  store = mono_mempool_alloc (D.30941, 80);
                  store->data.op[1].const_val = 0;
                  D.33579 = store->data.op[1].const_val;
                  store->data.op[0].const_val = D.33579;
                  store->prev = 0B;
                  D.33580 = store->prev;
                  store->next = D.33580;
                  store->opcode = 424;
                  store->flags = 0;
                  store->type = 0;
                  store->dreg = -1;
                  store->sreg3 = -1;
                  D.33581 = store->sreg3;
                  store->sreg2 = D.33581;
                  D.33582 = store->sreg2;
                  store->sreg1 = D.33582;
                  D.31162 = cfg->ip;
                  store->cil_code = D.31162;
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33588 = D.33587->data.op[1].vtype;
                  D.33589 = mono_type_to_regmove (cfg, D.33588);
                  D.33590 = (short unsigned int) D.33589;
                  store->opcode = D.33590;
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33591 = D.33587->klass;
                  store->klass = D.33591;
                  D.31957 = *sp;
                  D.32139 = D.31957->dreg;
                  store->sreg1 = D.32139;
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33592 = D.33587->dreg;
                  store->dreg = D.33592;
                  D.33593 = store->opcode;
                  if (D.33593 == 427) goto <D.33594>; else goto <D.33595>;
                  <D.33594>:
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33588 = D.33587->data.op[1].vtype;
                  D.33596 = mono_class_from_mono_type (D.33588);
                  store->klass = D.33596;
                  <D.33595>:
                  bblock.70 = bblock;
                  D.31279 = bblock.70->last_ins;
                  if (D.31279 != 0B) goto <D.33597>; else goto <D.33598>;
                  <D.33597>:
                  bblock.70 = bblock;
                  D.31279 = bblock.70->last_ins;
                  D.31279->next = store;
                  bblock.70 = bblock;
                  D.31279 = bblock.70->last_ins;
                  store->prev = D.31279;
                  bblock.70 = bblock;
                  bblock.70->last_ins = store;
                  goto <D.33599>;
                  <D.33598>:
                  bblock.70 = bblock;
                  bblock.70 = bblock;
                  bblock.70->last_ins = store;
                  D.31279 = bblock.70->last_ins;
                  bblock.70->code = D.31279;
                  <D.33599>:
                  D.31348 = mono_defaults.int_class;
                  D.31349 = &D.31348->byval_arg;
                  this_arg_temp = mono_compile_create_var (cfg, D.31349, 329);
                  D.30941 = cfg->mempool;
                  D.33600 = mono_mempool_alloc (D.30941, 80);
                  iargs[0] = D.33600;
                  D.33601 = iargs[0];
                  D.33601 = iargs[0];
                  D.33601->data.op[1].const_val = 0;
                  D.33602 = D.33601->data.op[1].const_val;
                  D.33601->data.op[0].const_val = D.33602;
                  D.33601 = iargs[0];
                  D.33601 = iargs[0];
                  D.33601->prev = 0B;
                  D.33603 = D.33601->prev;
                  D.33601->next = D.33603;
                  D.33601 = iargs[0];
                  D.33601->opcode = 424;
                  D.33601 = iargs[0];
                  D.33601->flags = 0;
                  D.33601 = iargs[0];
                  D.33601->type = 0;
                  D.33601 = iargs[0];
                  D.33601->dreg = -1;
                  D.33601 = iargs[0];
                  D.33601 = iargs[0];
                  D.33601 = iargs[0];
                  D.33601->sreg3 = -1;
                  D.33604 = D.33601->sreg3;
                  D.33601->sreg2 = D.33604;
                  D.33605 = D.33601->sreg2;
                  D.33601->sreg1 = D.33605;
                  D.33601 = iargs[0];
                  D.31162 = cfg->ip;
                  D.33601->cil_code = D.31162;
                  D.33601 = iargs[0];
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33588 = D.33587->data.op[1].vtype;
                  D.33606 = mono_type_to_regmove (cfg, D.33588);
                  D.33607 = (short unsigned int) D.33606;
                  D.33601->opcode = D.33607;
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33588 = D.33587->data.op[1].vtype;
                  D.33601 = iargs[0];
                  type_to_eval_stack_type (cfg, D.33588, D.33601);
                  D.33601 = iargs[0];
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33591 = D.33587->klass;
                  D.33601->klass = D.33591;
                  D.33601 = iargs[0];
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33592 = D.33587->dreg;
                  D.33601->sreg1 = D.33592;
                  D.33601 = iargs[0];
                  D.33601 = iargs[0];
                  D.33608 = D.33601->type;
                  D.33609 = (<unnamed type>) D.33608;
                  D.33610 = alloc_dreg (cfg, D.33609);
                  D.33611 = (int) D.33610;
                  D.33601->dreg = D.33611;
                  D.33601 = iargs[0];
                  D.33612 = D.33601->opcode;
                  if (D.33612 == 427) goto <D.33613>; else goto <D.33614>;
                  <D.33613>:
                  D.33601 = iargs[0];
                  D.31695 = cfg->varinfo;
                  D.33583 = this_temp->data.op[0].const_val;
                  D.33584 = (long unsigned int) D.33583;
                  D.33585 = D.33584 * 8;
                  D.33586 = D.31695 + D.33585;
                  D.33587 = *D.33586;
                  D.33588 = D.33587->data.op[1].vtype;
                  D.33615 = mono_class_from_mono_type (D.33588);
                  D.33601->klass = D.33615;
                  <D.33614>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33616>; else goto <D.33617>;
                  <D.33616>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33601 = iargs[0];
                  D.31191->next = D.33601;
                  D.33601 = iargs[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33601->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33601 = iargs[0];
                  bblock.113->last_ins = D.33601;
                  goto <D.33618>;
                  <D.33617>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33601 = iargs[0];
                  bblock.113->last_ins = D.33601;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33618>:
                  D.33619 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
                  iargs[1] = D.33619;
                  D.30941 = cfg->mempool;
                  D.33620 = mono_mempool_alloc (D.30941, 80);
                  iargs[2] = D.33620;
                  D.33621 = iargs[2];
                  D.33621 = iargs[2];
                  D.33621->data.op[1].const_val = 0;
                  D.33622 = D.33621->data.op[1].const_val;
                  D.33621->data.op[0].const_val = D.33622;
                  D.33621 = iargs[2];
                  D.33621 = iargs[2];
                  D.33621->prev = 0B;
                  D.33623 = D.33621->prev;
                  D.33621->next = D.33623;
                  D.33621 = iargs[2];
                  D.33621->opcode = 314;
                  D.33621 = iargs[2];
                  D.33621->flags = 0;
                  D.33621 = iargs[2];
                  D.33621->type = 0;
                  D.33621 = iargs[2];
                  D.33621->dreg = -1;
                  D.33621 = iargs[2];
                  D.33621 = iargs[2];
                  D.33621 = iargs[2];
                  D.33621->sreg3 = -1;
                  D.33624 = D.33621->sreg3;
                  D.33621->sreg2 = D.33624;
                  D.33625 = D.33621->sreg2;
                  D.33621->sreg1 = D.33625;
                  D.33621 = iargs[2];
                  D.31162 = cfg->ip;
                  D.33621->cil_code = D.31162;
                  D.33621 = iargs[2];
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33621->data.op[0].p = D.33630;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33631 = D.33630->flags;
                  D.33632 = D.33631 | 16;
                  D.33630->flags = D.33632;
                  D.33621 = iargs[2];
                  D.33621->type = 5;
                  D.33621 = iargs[2];
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33633 = D.33630->klass;
                  D.33621->klass = D.33633;
                  D.33621 = iargs[2];
                  D.33634 = alloc_dreg (cfg, 5);
                  D.33635 = (int) D.33634;
                  D.33621->dreg = D.33635;
                  cfg->has_indirection = 1;
                  D.31089 = cfg->gsharedvt;
                  D.32043 = D.31089 != 0;
                  D.32044 = (long int) D.32043;
                  D.32045 = __builtin_expect (D.32044, 0);
                  if (D.32045 != 0) goto <D.33636>; else goto <D.33637>;
                  <D.33636>:
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33638 = D.33630->data.op[1].vtype;
                  D.33639 = mini_is_gsharedvt_variable_type (cfg, D.33638);
                  if (D.33639 != 0) goto <D.33640>; else goto <D.33641>;
                  <D.33640>:
                  handle_gsharedvt_ldaddr (cfg);
                  <D.33641>:
                  <D.33637>:
                  if (0 != 0) goto <D.33642>; else goto <D.33643>;
                  <D.33642>:
                  {
                    struct MonoInst * var1;
                    struct MonoInst * var2;

                    D.31695 = cfg->varinfo;
                    D.33626 = this_arg_temp->data.op[0].const_val;
                    D.33627 = (long unsigned int) D.33626;
                    D.33628 = D.33627 * 8;
                    D.33629 = D.31695 + D.33628;
                    D.33630 = *D.33629;
                    D.33645 = D.33630->dreg;
                    D.33646 = D.33645 + 1;
                    D.33647 = (unsigned int) D.33646;
                    D.32058 = cfg->vreg_to_inst_len;
                    if (D.33647 < D.32058) goto <D.33648>; else goto <D.33649>;
                    <D.33648>:
                    D.32061 = cfg->vreg_to_inst;
                    D.31695 = cfg->varinfo;
                    D.33626 = this_arg_temp->data.op[0].const_val;
                    D.33627 = (long unsigned int) D.33626;
                    D.33628 = D.33627 * 8;
                    D.33629 = D.31695 + D.33628;
                    D.33630 = *D.33629;
                    D.33645 = D.33630->dreg;
                    D.33650 = (sizetype) D.33645;
                    D.33651 = D.33650 + 1;
                    D.33652 = D.33651 * 8;
                    D.33653 = D.32061 + D.33652;
                    iftmp.120 = *D.33653;
                    goto <D.33654>;
                    <D.33649>:
                    iftmp.120 = 0B;
                    <D.33654>:
                    var1 = iftmp.120;
                    D.31695 = cfg->varinfo;
                    D.33626 = this_arg_temp->data.op[0].const_val;
                    D.33627 = (long unsigned int) D.33626;
                    D.33628 = D.33627 * 8;
                    D.33629 = D.31695 + D.33628;
                    D.33630 = *D.33629;
                    D.33645 = D.33630->dreg;
                    D.33656 = D.33645 + 2;
                    D.33657 = (unsigned int) D.33656;
                    D.32058 = cfg->vreg_to_inst_len;
                    if (D.33657 < D.32058) goto <D.33658>; else goto <D.33659>;
                    <D.33658>:
                    D.32061 = cfg->vreg_to_inst;
                    D.31695 = cfg->varinfo;
                    D.33626 = this_arg_temp->data.op[0].const_val;
                    D.33627 = (long unsigned int) D.33626;
                    D.33628 = D.33627 * 8;
                    D.33629 = D.31695 + D.33628;
                    D.33630 = *D.33629;
                    D.33645 = D.33630->dreg;
                    D.33650 = (sizetype) D.33645;
                    D.33660 = D.33650 + 2;
                    D.33661 = D.33660 * 8;
                    D.33662 = D.32061 + D.33661;
                    iftmp.121 = *D.33662;
                    goto <D.33663>;
                    <D.33659>:
                    iftmp.121 = 0B;
                    <D.33663>:
                    var2 = iftmp.121;
                    D.33664 = var1 == 0B;
                    D.33665 = (long int) D.33664;
                    D.33666 = __builtin_expect (D.33665, 0);
                    if (D.33666 != 0) goto <D.33667>; else goto <D.33668>;
                    <D.33667>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8062, "var1");
                    <D.33668>:
                    D.33669 = var2 == 0B;
                    D.33670 = (long int) D.33669;
                    D.33671 = __builtin_expect (D.33670, 0);
                    if (D.33671 != 0) goto <D.33672>; else goto <D.33673>;
                    <D.33672>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8062, "var2");
                    <D.33673>:
                    D.33674 = var1->flags;
                    D.33675 = D.33674 | 16;
                    var1->flags = D.33675;
                    D.33676 = var2->flags;
                    D.33677 = D.33676 | 16;
                    var2->flags = D.33677;
                  }
                  <D.33643>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33678>; else goto <D.33679>;
                  <D.33678>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33621 = iargs[2];
                  D.31191->next = D.33621;
                  D.33621 = iargs[2];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.33621->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.33621 = iargs[2];
                  bblock.113->last_ins = D.33621;
                  goto <D.33680>;
                  <D.33679>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.33621 = iargs[2];
                  bblock.113->last_ins = D.33621;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33680>:
                  addr = mono_emit_jit_icall (cfg, mono_helper_compile_generic_method, &iargs);
                  D.30941 = cfg->mempool;
                  D.33681 = mono_mempool_alloc (D.30941, 80);
                  *sp = D.33681;
                  D.31957 = *sp;
                  D.31957 = *sp;
                  D.31957->data.op[1].const_val = 0;
                  D.33682 = D.31957->data.op[1].const_val;
                  D.31957->data.op[0].const_val = D.33682;
                  D.31957 = *sp;
                  D.31957 = *sp;
                  D.31957->prev = 0B;
                  D.33683 = D.31957->prev;
                  D.31957->next = D.33683;
                  D.31957 = *sp;
                  D.31957->opcode = 424;
                  D.31957 = *sp;
                  D.31957->flags = 0;
                  D.31957 = *sp;
                  D.31957->type = 0;
                  D.31957 = *sp;
                  D.31957->dreg = -1;
                  D.31957 = *sp;
                  D.31957 = *sp;
                  D.31957 = *sp;
                  D.31957->sreg3 = -1;
                  D.33684 = D.31957->sreg3;
                  D.31957->sreg2 = D.33684;
                  D.33685 = D.31957->sreg2;
                  D.31957->sreg1 = D.33685;
                  D.31957 = *sp;
                  D.31162 = cfg->ip;
                  D.31957->cil_code = D.31162;
                  D.31957 = *sp;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33638 = D.33630->data.op[1].vtype;
                  D.33686 = mono_type_to_regmove (cfg, D.33638);
                  D.33687 = (short unsigned int) D.33686;
                  D.31957->opcode = D.33687;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33638 = D.33630->data.op[1].vtype;
                  D.31957 = *sp;
                  type_to_eval_stack_type (cfg, D.33638, D.31957);
                  D.31957 = *sp;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33633 = D.33630->klass;
                  D.31957->klass = D.33633;
                  D.31957 = *sp;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33645 = D.33630->dreg;
                  D.31957->sreg1 = D.33645;
                  D.31957 = *sp;
                  D.31957 = *sp;
                  D.33688 = D.31957->type;
                  D.33689 = (<unnamed type>) D.33688;
                  D.33690 = alloc_dreg (cfg, D.33689);
                  D.33691 = (int) D.33690;
                  D.31957->dreg = D.33691;
                  D.31957 = *sp;
                  D.33692 = D.31957->opcode;
                  if (D.33692 == 427) goto <D.33693>; else goto <D.33694>;
                  <D.33693>:
                  D.31957 = *sp;
                  D.31695 = cfg->varinfo;
                  D.33626 = this_arg_temp->data.op[0].const_val;
                  D.33627 = (long unsigned int) D.33626;
                  D.33628 = D.33627 * 8;
                  D.33629 = D.31695 + D.33628;
                  D.33630 = *D.33629;
                  D.33638 = D.33630->data.op[1].vtype;
                  D.33695 = mono_class_from_mono_type (D.33638);
                  D.31957->klass = D.33695;
                  <D.33694>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.33696>; else goto <D.33697>;
                  <D.33696>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31957 = *sp;
                  D.31191->next = D.31957;
                  D.31957 = *sp;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31957->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.31957 = *sp;
                  bblock.113->last_ins = D.31957;
                  goto <D.33698>;
                  <D.33697>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.31957 = *sp;
                  bblock.113->last_ins = D.31957;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.33698>:
                  ins = mono_emit_calli (cfg, fsig, sp, addr, 0B, 0B);
                  <D.33577>:
                  goto call_end;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.33516>:
            <D.33531>:
            <D.33519>:
            <D.33525>:
            <D.33523>:
            <D.33521>:
            if (cmethod != 0B) goto <D.33699>; else goto <D.33700>;
            <D.33699>:
            D.32828 = cmethod->klass;
            D.33701 = mono_defaults.monitor_class;
            if (D.32828 == D.33701) goto <D.33702>; else goto <D.33703>;
            <D.33702>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 5;
              if (__s2_len <= 3) goto <D.33705>; else goto <D.33706>;
              <D.33705>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = cmethod->name;
                D.33707 = "Enter";
                D.33708 = MEM[(const unsigned char *)D.33707];
                D.33709 = (int) D.33708;
                D.33710 = *__s2;
                D.33711 = (int) D.33710;
                __result = D.33709 - D.33711;
                {
                  if (__s2_len != 0) goto <D.33712>; else goto <D.33713>;
                  <D.33712>:
                  if (__result == 0) goto <D.33714>; else goto <D.33715>;
                  <D.33714>:
                  D.33716 = &MEM[(void *)"Enter" + 1B];
                  D.33717 = *D.33716;
                  D.33718 = (int) D.33717;
                  D.33719 = __s2 + 1;
                  D.33720 = *D.33719;
                  D.33721 = (int) D.33720;
                  __result = D.33718 - D.33721;
                  if (__s2_len > 1) goto <D.33722>; else goto <D.33723>;
                  <D.33722>:
                  if (__result == 0) goto <D.33724>; else goto <D.33725>;
                  <D.33724>:
                  D.33726 = &MEM[(void *)"Enter" + 2B];
                  D.33727 = *D.33726;
                  D.33728 = (int) D.33727;
                  D.33729 = __s2 + 2;
                  D.33730 = *D.33729;
                  D.33731 = (int) D.33730;
                  __result = D.33728 - D.33731;
                  if (__s2_len > 2) goto <D.33732>; else goto <D.33733>;
                  <D.33732>:
                  if (__result == 0) goto <D.33734>; else goto <D.33735>;
                  <D.33734>:
                  D.33736 = &MEM[(void *)"Enter" + 3B];
                  D.33737 = *D.33736;
                  D.33738 = (int) D.33737;
                  D.33739 = __s2 + 3;
                  D.33740 = *D.33739;
                  D.33741 = (int) D.33740;
                  __result = D.33738 - D.33741;
                  <D.33735>:
                  <D.33733>:
                  <D.33725>:
                  <D.33723>:
                  <D.33715>:
                  <D.33713>:
                }
                D.28005 = __result;
              }
              iftmp.122 = -D.28005;
              goto <D.33742>;
              <D.33706>:
              D.33344 = cmethod->name;
              iftmp.122 = __builtin_strcmp (D.33344, "Enter");
              <D.33742>:
              D.28006 = iftmp.122;
            }
            if (D.28006 == 0) goto <D.33743>; else goto <D.33744>;
            <D.33743>:
            D.33745 = mono_method_signature (cmethod);
            D.33746 = D.33745->param_count;
            if (D.33746 == 1) goto <D.33747>; else goto <D.33748>;
            <D.33747>:
            {
              struct MonoBasicBlock * tbb;

              D.31071 = cfg->cil_offset_to_bb;
              D.32381 = ip + 5;
              D.32926 = (long int) D.32381;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.33749 = D.32926 - D.31077;
              D.33750 = (long unsigned int) D.33749;
              D.33751 = D.33750 * 8;
              D.33752 = D.31071 + D.33751;
              tbb = *D.33752;
              if (tbb == 0B) goto <D.33753>; else goto <D.33754>;
              <D.33753>:
              D.32381 = ip + 5;
              if (D.32381 >= end) goto <D.33755>; else goto <D.33757>;
              <D.33757>:
              D.33758 = ip + 5;
              D.31088 = header->code;
              if (D.33758 < D.31088) goto <D.33755>; else goto <D.33756>;
              <D.33755>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.33759>; else goto <D.33760>;
              <D.33759>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 2) goto <D.33761>; else goto <D.33762>;
              <D.33761>:
              printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
              <D.33762>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33760>:
              D.33763 = mini_get_debug_options ();
              D.33764 = D.33763->break_on_unverified;
              if (D.33764 != 0) goto <D.33765>; else goto unverified;
              <D.33765>:
              raise (5);
              <D.33756>:
              D.30941 = cfg->mempool;
              tbb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.33766 = D.31048;
              D.33767 = D.33766 + 1;
              cfg->num_bblocks = D.33767;
              D.33768 = (int) D.33766;
              tbb->block_num = D.33768;
              D.32381 = ip + 5;
              tbb->cil_code = D.32381;
              D.33769 = tbb->cil_code;
              if (D.33769 != 0B) goto <D.33770>; else goto <D.33771>;
              <D.33770>:
              D.31071 = cfg->cil_offset_to_bb;
              D.33769 = tbb->cil_code;
              D.33772 = (long int) D.33769;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.33773 = D.33772 - D.31077;
              D.33774 = (long unsigned int) D.33773;
              D.33775 = D.33774 * 8;
              D.33776 = D.31071 + D.33775;
              *D.33776 = tbb;
              <D.33771>:
              D.31108 = cfg->real_offset;
              tbb->real_offset = D.31108;
              <D.33754>:
              D.33777 = BIT_FIELD_REF <*tbb, 64, 1472>;
              D.33778 = D.33777 & 4194304;
              if (D.33778 != 0) goto <D.33779>; else goto <D.33780>;
              <D.33779>:
              D.33781 = tbb->region;
              D.33782 = D.33781 & 7;
              if (D.33782 == 2) goto <D.33783>; else goto <D.33784>;
              <D.33783>:
              tbb->extend_try_block = 1;
              <D.33784>:
              <D.33780>:
            }
            <D.33748>:
            <D.33744>:
            <D.33703>:
            <D.33700>:
            if (cmethod != 0B) goto <D.33785>; else goto <D.33786>;
            <D.33785>:
            D.31334 = cfg->opt;
            D.33349 = D.31334 & 2048;
            if (D.33349 != 0) goto <D.33787>; else goto <D.33788>;
            <D.33787>:
            ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp);
            if (ins != 0B) goto <D.33789>; else goto <D.33790>;
            <D.33789>:
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            D.32915 = fsig->ret;
            D.33791 = mono_type_is_void (D.32915);
            if (D.33791 == 0) goto <D.33792>; else goto <D.33793>;
            <D.33792>:
            D.32915 = fsig->ret;
            type_to_eval_stack_type (cfg, D.32915, ins);
            emit_widen = 0;
            <D.33793>:
            goto call_end;
            <D.33790>:
            <D.33788>:
            <D.33786>:
            if (cmethod != 0B) goto <D.33796>; else goto <D.33797>;
            <D.33796>:
            D.31334 = cfg->opt;
            D.33798 = D.31334 & 4;
            if (D.33798 != 0) goto <D.33799>; else goto <D.33800>;
            <D.33799>:
            if (virtual == 0) goto <D.33794>; else goto <D.33801>;
            <D.33801>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33457 = D.32865 & 64;
            if (D.33457 == 0) goto <D.33794>; else goto <D.33802>;
            <D.33802>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33459 = D.32865 & 32;
            if (D.33459 != 0) goto <D.33794>; else goto <D.33803>;
            <D.33803>:
            D.32828 = cmethod->klass;
            if (D.32828 != 0B) goto <D.33804>; else goto <D.33795>;
            <D.33804>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33462 = D.33007 & 256;
            if (D.33462 != 0) goto <D.33794>; else goto <D.33795>;
            <D.33794>:
            if (disable_inline == 0) goto <D.33805>; else goto <D.33806>;
            <D.33805>:
            D.33807 = mono_method_check_inlining (cfg, cmethod);
            if (D.33807 != 0) goto <D.33808>; else goto <D.33809>;
            <D.33808>:
            D.33810 = monoeg_g_list_find (dont_inline, cmethod);
            if (D.33810 == 0B) goto <D.33811>; else goto <D.33812>;
            <D.33811>:
            {
              int costs;
              gboolean always;

              always = 0;
              D.32894 = cmethod->iflags;
              D.32895 = (int) D.32894;
              D.32896 = D.32895 & 4096;
              if (D.32896 != 0) goto <D.33813>; else goto <D.33815>;
              <D.33815>:
              D.32864 = cmethod->flags;
              D.32865 = (int) D.32864;
              D.33816 = D.32865 & 8192;
              if (D.33816 != 0) goto <D.33813>; else goto <D.33814>;
              <D.33813>:
              D.30911 = cfg->method;
              if (D.30911 != method) goto <D.33817>; else goto <D.33818>;
              <D.33817>:
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 == 0) goto <D.33819>; else goto <D.33820>;
              <D.33819>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.33821>; else goto <D.33822>;
              <D.33821>:
              printf ("inline failed: %s\n", "wrapper call");
              <D.33822>:
              goto inline_failure;
              <D.33820>:
              <D.33818>:
              check_for_pending_exc.107 = check_for_pending_exc;
              cmethod = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc.107, 0);
              always = 1;
              <D.33814>:
              D.31108 = cfg->real_offset;
              costs = inline_method (cfg, cmethod, fsig, sp, ip, D.31108, dont_inline, always);
              if (costs != 0) goto <D.33823>; else goto <D.33824>;
              <D.33823>:
              D.31108 = cfg->real_offset;
              D.33825 = D.31108 + 5;
              cfg->real_offset = D.33825;
              bblock.113 = cfg->cbb;
              bblock = bblock.113;
              D.32915 = fsig->ret;
              D.33826 = mono_type_is_void (D.32915);
              if (D.33826 == 0) goto <D.33827>; else goto <D.33828>;
              <D.33827>:
              sp = sp + 8;
              push_res = 0;
              <D.33828>:
              inline_costs = inline_costs + costs;
              goto call_end;
              <D.33824>:
            }
            <D.33812>:
            <D.33809>:
            <D.33806>:
            <D.33795>:
            <D.33800>:
            <D.33797>:
            D.31334 = cfg->opt;
            D.33829 = D.31334 & 4096;
            if (D.33829 != 0) goto <D.33830>; else goto <D.33831>;
            <D.33830>:
            if (call_opcode == 40) goto <D.33832>; else goto <D.33833>;
            <D.33832>:
            if (cmethod == method) goto <D.33834>; else goto <D.33835>;
            <D.33834>:
            D.32381 = ip + 5;
            D.32923 = *D.32381;
            if (D.32923 == 42) goto <D.33836>; else goto <D.33837>;
            <D.33836>:
            if (vtable_arg == 0B) goto <D.33838>; else goto <D.33839>;
            <D.33838>:
            {
              gboolean has_vtargs;
              int i;

              has_vtargs = 0;
              D.30911 = cfg->method;
              if (D.30911 != method) goto <D.33840>; else goto <D.33841>;
              <D.33840>:
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 == 0) goto <D.33842>; else goto <D.33843>;
              <D.33842>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.33844>; else goto <D.33845>;
              <D.33844>:
              printf ("inline failed: %s\n", "tail call");
              <D.33845>:
              goto inline_failure;
              <D.33843>:
              <D.33841>:
              D.32757 = fsig->param_count;
              D.32758 = (int) D.32757;
              i = D.32758 + -1;
              goto <D.28013>;
              <D.28012>:
              D.33846 = mono_method_signature (cmethod);
              D.33847 = D.33846->params[i];
              D.33848 = mono_type_is_struct (D.33847);
              if (D.33848 != 0) goto <D.33849>; else goto <D.33850>;
              <D.33849>:
              has_vtargs = 1;
              <D.33850>:
              i = i + -1;
              <D.28013>:
              if (i >= 0) goto <D.28012>; else goto <D.28014>;
              <D.28014>:
              if (has_vtargs == 0) goto <D.33851>; else goto <D.33852>;
              <D.33851>:
              i = 0;
              goto <D.28016>;
              <D.28015>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              D.31569 = cfg->arg_types;
              D.33853 = (long unsigned int) i;
              D.33854 = D.33853 * 8;
              D.33855 = D.31569 + D.33854;
              D.33856 = *D.33855;
              D.33857 = mono_type_to_regmove (cfg, D.33856);
              D.33858 = (short unsigned int) D.33857;
              ins->opcode = D.33858;
              D.31559 = cfg->args;
              D.33853 = (long unsigned int) i;
              D.33854 = D.33853 * 8;
              D.33859 = D.31559 + D.33854;
              D.33860 = *D.33859;
              D.33861 = D.33860->klass;
              ins->klass = D.33861;
              D.33853 = (long unsigned int) i;
              D.33854 = D.33853 * 8;
              D.33862 = sp + D.33854;
              D.33863 = *D.33862;
              D.33864 = D.33863->dreg;
              ins->sreg1 = D.33864;
              D.31559 = cfg->args;
              D.33853 = (long unsigned int) i;
              D.33854 = D.33853 * 8;
              D.33859 = D.31559 + D.33854;
              D.33860 = *D.33859;
              D.33865 = D.33860->dreg;
              ins->dreg = D.33865;
              D.31709 = ins->opcode;
              if (D.31709 == 427) goto <D.33866>; else goto <D.33867>;
              <D.33866>:
              D.31569 = cfg->arg_types;
              D.33853 = (long unsigned int) i;
              D.33854 = D.33853 * 8;
              D.33855 = D.31569 + D.33854;
              D.33856 = *D.33855;
              D.33868 = mono_class_from_mono_type (D.33856);
              ins->klass = D.33868;
              <D.33867>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.33869>; else goto <D.33870>;
              <D.33869>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.33871>;
              <D.33870>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.33871>:
              i = i + 1;
              <D.28016>:
              if (i < n) goto <D.28015>; else goto <D.28017>;
              <D.28017>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 442;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              if (D.31279 != 0B) goto <D.33872>; else goto <D.33873>;
              <D.33872>:
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              D.31279->next = ins;
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              ins->prev = D.31279;
              bblock.70 = bblock;
              bblock.70->last_ins = ins;
              goto <D.33874>;
              <D.33873>:
              bblock.70 = bblock;
              bblock.70 = bblock;
              bblock.70->last_ins = ins;
              D.31279 = bblock.70->last_ins;
              bblock.70->code = D.31279;
              <D.33874>:
              D.33875 = start_bblock->out_bb;
              tblock = *D.33875;
              bblock.70 = bblock;
              link_bblock (cfg, bblock.70, tblock);
              ins->data.op[0].target_block = tblock;
              start_new_bblock = 1;
              bblock.70 = bblock;
              D.33876 = ip + 5;
              D.33877 = ip_in_bb (cfg, bblock.70, D.33876);
              if (D.33877 != 0) goto <D.33878>; else goto <D.33879>;
              <D.33878>:
              skip_ret = 1;
              <D.33879>:
              push_res = 0;
              goto call_end;
              <D.33852>:
            }
            <D.33839>:
            <D.33837>:
            <D.33835>:
            <D.33833>:
            <D.33831>:
            num_calls.123 = num_calls;
            num_calls = num_calls.123 + 1;
            D.33881 = num_calls.123 * 10;
            inline_costs = D.33881 + inline_costs;
            if (cmethod != 0B) goto <D.33883>; else goto <D.33882>;
            <D.33883>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.33884>; else goto <D.33882>;
            <D.33884>:
            D.33885 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.33885 != 0) goto <D.33886>; else goto <D.33882>;
            <D.33886>:
            {
              MonoRgctxInfoType info_type;

              if (virtual != 0) goto <D.33887>; else goto <D.33888>;
              <D.33887>:
              D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
              D.33072 = D.32764 & 18014398509481984;
              if (D.33072 != 0) goto <D.33891>; else goto <D.33892>;
              <D.33891>:
              D.30878 = method->klass;
              D.31030 = BIT_FIELD_REF <*D.30878, 64, 256>;
              D.33893 = D.31030 & 4194304;
              if (D.33893 != 0) goto <D.33889>; else goto <D.33894>;
              <D.33894>:
              D.30878 = method->klass;
              D.32996 = mono_defaults.object_class;
              if (D.30878 == D.32996) goto <D.33889>; else goto <D.33890>;
              <D.33889>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.33895>; else goto <D.33896>;
              <D.33895>:
              D.30878 = method->klass;
              D.32629 = D.30878->name_space;
              D.30878 = method->klass;
              D.32630 = D.30878->name;
              D.32631 = method->name;
              D.32632 = method->signature;
              D.32633 = D.32632->param_count;
              D.32634 = (int) D.32633;
              D.31838 = *ip;
              D.31839 = (int) D.31838;
              D.33897 = mono_opcode_name (D.31839);
              D.33898 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.33897, "method-to-ir.c", 8189);
              cfg->exception_message = D.33898;
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.33899>; else goto <D.33900>;
              <D.33899>:
              D.32639 = cfg->exception_message;
              printf ("%s\n", D.32639);
              <D.33900>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33896>:
              <D.33890>:
              <D.33892>:
              D.33529 = fsig->generic_param_count;
              if (D.33529 != 0) goto <D.33901>; else goto <D.33902>;
              <D.33901>:
              mono_use_imt.119 = mono_use_imt;
              D.33903 = mono_use_imt.119 == 0;
              D.33904 = (long int) D.33903;
              D.33905 = __builtin_expect (D.33904, 0);
              if (D.33905 != 0) goto <D.33906>; else goto <D.33907>;
              <D.33906>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8192, "mono_use_imt");
              <D.33907>:
              D.33564 = imt_arg != 0B;
              D.33565 = (long int) D.33564;
              D.33566 = __builtin_expect (D.33565, 0);
              if (D.33566 != 0) goto <D.33908>; else goto <D.33909>;
              <D.33908>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8193, "!imt_arg");
              <D.33909>:
              imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
              vtable_arg = 0B;
              <D.33902>:
              <D.33888>:
              D.32828 = cmethod->klass;
              D.32900 = D.32828->rank;
              if (D.32900 != 0) goto <D.33910>; else goto <D.33911>;
              <D.33910>:
              D.32828 = cmethod->klass;
              D.33912 = D.32828->byval_arg.type;
              if (D.33912 != 29) goto <D.33913>; else goto <D.33914>;
              <D.33913>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.33915>; else goto <D.33916>;
              <D.33915>:
              D.30878 = method->klass;
              D.32629 = D.30878->name_space;
              D.30878 = method->klass;
              D.32630 = D.30878->name;
              D.32631 = method->name;
              D.32632 = method->signature;
              D.32633 = D.32632->param_count;
              D.32634 = (int) D.32633;
              D.31838 = *ip;
              D.31839 = (int) D.31838;
              D.33917 = mono_opcode_name (D.31839);
              D.33918 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.33917, "method-to-ir.c", 8204);
              cfg->exception_message = D.33918;
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.33919>; else goto <D.33920>;
              <D.33919>:
              D.32639 = cfg->exception_message;
              printf ("%s\n", D.32639);
              <D.33920>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33916>:
              <D.33914>:
              <D.33911>:
              D.32828 = cmethod->klass;
              D.33301 = D.32828->parent;
              D.33302 = mono_defaults.multicastdelegate_class;
              if (D.33301 == D.33302) goto <D.33921>; else goto <D.33922>;
              <D.33921>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 6;
                if (__s2_len <= 3) goto <D.33924>; else goto <D.33925>;
                <D.33924>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = cmethod->name;
                  D.33308 = "Invoke";
                  D.33309 = MEM[(const unsigned char *)D.33308];
                  D.33310 = (int) D.33309;
                  D.33926 = *__s2;
                  D.33927 = (int) D.33926;
                  __result = D.33310 - D.33927;
                  {
                    if (__s2_len != 0) goto <D.33928>; else goto <D.33929>;
                    <D.33928>:
                    if (__result == 0) goto <D.33930>; else goto <D.33931>;
                    <D.33930>:
                    D.33317 = &MEM[(void *)"Invoke" + 1B];
                    D.33318 = *D.33317;
                    D.33319 = (int) D.33318;
                    D.33932 = __s2 + 1;
                    D.33933 = *D.33932;
                    D.33934 = (int) D.33933;
                    __result = D.33319 - D.33934;
                    if (__s2_len > 1) goto <D.33935>; else goto <D.33936>;
                    <D.33935>:
                    if (__result == 0) goto <D.33937>; else goto <D.33938>;
                    <D.33937>:
                    D.33327 = &MEM[(void *)"Invoke" + 2B];
                    D.33328 = *D.33327;
                    D.33329 = (int) D.33328;
                    D.33939 = __s2 + 2;
                    D.33940 = *D.33939;
                    D.33941 = (int) D.33940;
                    __result = D.33329 - D.33941;
                    if (__s2_len > 2) goto <D.33942>; else goto <D.33943>;
                    <D.33942>:
                    if (__result == 0) goto <D.33944>; else goto <D.33945>;
                    <D.33944>:
                    D.33337 = &MEM[(void *)"Invoke" + 3B];
                    D.33338 = *D.33337;
                    D.33339 = (int) D.33338;
                    D.33946 = __s2 + 3;
                    D.33947 = *D.33946;
                    D.33948 = (int) D.33947;
                    __result = D.33339 - D.33948;
                    <D.33945>:
                    <D.33943>:
                    <D.33938>:
                    <D.33936>:
                    <D.33931>:
                    <D.33929>:
                  }
                  D.28026 = __result;
                }
                iftmp.124 = -D.28026;
                goto <D.33949>;
                <D.33925>:
                D.33344 = cmethod->name;
                iftmp.124 = __builtin_strcmp (D.33344, "Invoke");
                <D.33949>:
                D.28027 = iftmp.124;
              }
              if (D.28027 == 0) goto <D.33950>; else goto <D.33951>;
              <D.33950>:
              keep_this_alive = *sp;
              <D.33951>:
              <D.33922>:
              if (virtual != 0) goto <D.33954>; else goto <D.33952>;
              <D.33954>:
              D.32864 = cmethod->flags;
              D.32865 = (int) D.32864;
              D.33457 = D.32865 & 64;
              if (D.33457 != 0) goto <D.33955>; else goto <D.33952>;
              <D.33955>:
              info_type = 17;
              goto <D.33953>;
              <D.33952>:
              info_type = 16;
              <D.33953>:
              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.33882>:
            if (calli != 0) goto <D.33956>; else goto <D.33957>;
            <D.33956>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.33958>; else goto <D.33959>;
            <D.33958>:
            D.33960 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.33960 != 0) goto <D.33961>; else goto <D.33962>;
            <D.33961>:
            {
              struct MonoInst * callee;

              callee = addr;
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 != 4) goto <D.33963>; else goto <D.33964>;
              <D.33963>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.33965>; else goto <D.33966>;
              <D.33965>:
              D.30878 = method->klass;
              D.32629 = D.30878->name_space;
              D.30878 = method->klass;
              D.32630 = D.30878->name;
              D.32631 = method->name;
              D.32632 = method->signature;
              D.32633 = D.32632->param_count;
              D.32634 = (int) D.32633;
              D.31838 = *ip;
              D.31839 = (int) D.31838;
              D.33967 = mono_opcode_name (D.31839);
              D.33968 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.33967, "method-to-ir.c", 8225);
              cfg->exception_message = D.33968;
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.33969>; else goto <D.33970>;
              <D.33969>:
              D.32639 = cfg->exception_message;
              printf ("%s\n", D.32639);
              <D.33970>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33966>:
              <D.33964>:
              addr = emit_get_rgctx_sig (cfg, context_used, fsig, 18);
              ins = mono_emit_calli (cfg, fsig, sp, addr, 0B, callee);
              goto call_end;
            }
            <D.33962>:
            <D.33959>:
            <D.33957>:
            if (context_used != 0) goto <D.33975>; else goto <D.33976>;
            <D.33975>:
            if (imt_arg == 0B) goto <D.33977>; else goto <D.33978>;
            <D.33977>:
            D.33979 = array_rank | delegate_invoke;
            if (D.33979 == 0) goto <D.33980>; else goto <D.33981>;
            <D.33980>:
            D.33982 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.33982 == 0) goto <D.33974>; else goto <D.33983>;
            <D.33983>:
            D.32828 = cmethod->klass;
            D.33984 = mono_class_generic_sharing_enabled (D.32828);
            if (D.33984 == 0) goto <D.33974>; else goto <D.33973>;
            <D.33974>:
            if (virtual == 0) goto <D.33971>; else goto <D.33985>;
            <D.33985>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33459 = D.32865 & 32;
            if (D.33459 != 0) goto <D.33971>; else goto <D.33986>;
            <D.33986>:
            D.32828 = cmethod->klass;
            if (D.32828 != 0B) goto <D.33987>; else goto <D.33972>;
            <D.33987>:
            D.32828 = cmethod->klass;
            D.33007 = D.32828->flags;
            D.33462 = D.33007 & 256;
            if (D.33462 != 0) goto <D.33971>; else goto <D.33972>;
            <D.33972>:
            D.32864 = cmethod->flags;
            D.32865 = (int) D.32864;
            D.33457 = D.32865 & 64;
            if (D.33457 == 0) goto <D.33971>; else goto <D.33973>;
            <D.33971>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.33988>; else goto <D.33989>;
            <D.33988>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.33990>; else goto <D.33991>;
            <D.33990>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.33992>; else goto <D.33993>;
            <D.33992>:
            printf ("inline failed: %s\n", "gshared");
            <D.33993>:
            goto inline_failure;
            <D.33991>:
            <D.33989>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 == 0B) goto <D.33995>; else goto <D.33998>;
            <D.33998>:
            if (cmethod == 0B) goto <D.33995>; else goto <D.33996>;
            <D.33995>:
            iftmp.125 = 1;
            goto <D.33997>;
            <D.33996>:
            iftmp.125 = 0;
            <D.33997>:
            D.33999 = iftmp.125 != 0;
            D.34000 = (long int) D.33999;
            D.34001 = __builtin_expect (D.34000, 0);
            if (D.34001 != 0) goto <D.34002>; else goto <D.34003>;
            <D.34002>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8243, "cfg->generic_sharing_context && cmethod");
            <D.34003>:
            D.34004 = addr != 0B;
            D.34005 = (long int) D.34004;
            D.34006 = __builtin_expect (D.34005, 0);
            if (D.34006 != 0) goto <D.34007>; else goto <D.34008>;
            <D.34007>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8244, "!addr");
            <D.34008>:
            D.32764 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.33072 = D.32764 & 18014398509481984;
            if (D.33072 != 0) goto <D.34009>; else goto <D.34010>;
            <D.34009>:
            D.31372 = cfg->flags;
            D.31586 = D.31372 | 128;
            cfg->flags = D.31586;
            D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.31587 = D.30929 & 64;
            if (D.31587 != 0) goto <D.34011>; else goto <D.34012>;
            <D.34011>:
            D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.31587 = D.30929 & 64;
            if (D.31587 != 0) goto <D.34013>; else goto <D.34014>;
            <D.34013>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.34015 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.34015;
              inst->prev = 0B;
              D.34016 = inst->prev;
              inst->next = D.34016;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.34017 = inst->sreg3;
              inst->sreg2 = D.34017;
              D.34018 = inst->sreg2;
              inst->sreg1 = D.34018;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              inst->data.op[1].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34019>; else goto <D.34020>;
              <D.34019>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.34021>;
              <D.34020>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34021>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.34022 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.34022;
              inst->prev = 0B;
              D.34023 = inst->prev;
              inst->next = D.34023;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.34024 = inst->sreg3;
              inst->sreg2 = D.34024;
              D.34025 = inst->sreg2;
              inst->sreg1 = D.34025;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->data.op[1].p = "NullReferenceException";
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34026>; else goto <D.34027>;
              <D.34026>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.34028>;
              <D.34027>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34028>:
            }
            goto <D.34029>;
            <D.34014>:
            <D.34029>:
            goto <D.34030>;
            <D.34012>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.34031 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.34031;
              inst->prev = 0B;
              D.34032 = inst->prev;
              inst->next = D.34032;
              inst->opcode = 340;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.34033 = inst->sreg3;
              inst->sreg2 = D.34033;
              D.34034 = inst->sreg2;
              inst->sreg1 = D.34034;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34035>; else goto <D.34036>;
              <D.34035>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.34037>;
              <D.34036>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34037>:
            }
            <D.34030>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.34038 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.34038;
              inst->prev = 0B;
              D.34039 = inst->prev;
              inst->next = D.34039;
              inst->opcode = 799;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.34040 = inst->sreg3;
              inst->sreg2 = D.34040;
              D.34041 = inst->sreg2;
              inst->sreg1 = D.34041;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              inst->sreg1 = D.32139;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34042>; else goto <D.34043>;
              <D.34042>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.34044>;
              <D.34043>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34044>:
            }
            <D.34010>:
            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.33973>:
            <D.33981>:
            <D.33978>:
            <D.33976>:
            if (addr != 0B) goto <D.34045>; else goto <D.34046>;
            <D.34045>:
            if (call_opcode == 40) goto <D.34047>; else goto <D.34048>;
            <D.34047>:
            D.34049 = context_used == 0;
            D.34050 = (long int) D.34049;
            D.34051 = __builtin_expect (D.34050, 0);
            if (D.34051 != 0) goto <D.34052>; else goto <D.34053>;
            <D.34052>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8264, "context_used");
            <D.34053>:
            goto <D.34054>;
            <D.34048>:
            if (call_opcode == 41) goto <D.34055>; else goto <D.34056>;
            <D.34055>:
            D.33442 = vtable_arg != 0B;
            D.33443 = (long int) D.33442;
            D.33444 = __builtin_expect (D.33443, 0);
            if (D.33444 != 0) goto <D.34057>; else goto <D.34058>;
            <D.34057>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8266, "!vtable_arg");
            <D.34058>:
            goto <D.34059>;
            <D.34056>:
            if (0 != 0) goto <D.34060>; else goto <D.34061>;
            <D.34060>:
            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.34061>:
            <D.34059>:
            <D.34054>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.34062>; else goto <D.34063>;
            <D.34062>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.34064>; else goto <D.34065>;
            <D.34064>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.34066>; else goto <D.34067>;
            <D.34066>:
            printf ("inline failed: %s\n", "indirect call");
            <D.34067>:
            goto inline_failure;
            <D.34065>:
            <D.34063>:
            D.34070 = addr->opcode;
            if (D.34070 == 363) goto <D.34068>; else goto <D.34071>;
            <D.34071>:
            D.34070 = addr->opcode;
            if (D.34070 == 732) goto <D.34068>; else goto <D.34072>;
            <D.34072>:
            D.34070 = addr->opcode;
            if (D.34070 == 734) goto <D.34068>; else goto <D.34069>;
            <D.34068>:
            {
              int info_type;
              void * info_data;

              D.34070 = addr->opcode;
              if (D.34070 == 363) goto <D.34073>; else goto <D.34076>;
              <D.34076>:
              D.34070 = addr->opcode;
              if (D.34070 == 732) goto <D.34073>; else goto <D.34074>;
              <D.34073>:
              D.34077 = addr->data.op[1].const_val;
              info_type = (int) D.34077;
              info_data = addr->data.op[0].p;
              goto <D.34075>;
              <D.34074>:
              D.34078 = addr->data.op[1].src;
              D.34079 = D.34078->data.op[1].const_val;
              info_type = (int) D.34079;
              D.34078 = addr->data.op[1].src;
              info_data = D.34078->data.op[0].src;
              <D.34075>:
              info_type.126 = (unsigned int) info_type;
              D.34081 = info_type.126 + 4294967265;
              if (D.34081 <= 1) goto <D.34082>; else goto <D.34083>;
              <D.34082>:
              info_type.127 = (<unnamed type>) info_type;
              ins = mono_emit_abs_call (cfg, info_type.127, info_data, fsig, sp);
              addr->opcode = 316;
              addr->dreg = -1;
              addr->sreg3 = -1;
              D.34085 = addr->sreg3;
              addr->sreg2 = D.34085;
              D.34086 = addr->sreg2;
              addr->sreg1 = D.34086;
              goto call_end;
              <D.34083>:
            }
            <D.34069>:
            ins = mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
            goto call_end;
            <D.34046>:
            if (array_rank != 0) goto <D.34087>; else goto <D.34088>;
            <D.34087>:
            {
              struct MonoInst * addr;

              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = cmethod->name;
                  D.34092 = "Set";
                  D.34093 = MEM[(const unsigned char *)D.34092];
                  D.34094 = (int) D.34093;
                  D.34095 = *__s2;
                  D.34096 = (int) D.34095;
                  __result = D.34094 - D.34096;
                  {
                    if (__s2_len != 0) goto <D.34097>; else goto <D.34098>;
                    <D.34097>:
                    if (__result == 0) goto <D.34099>; else goto <D.34100>;
                    <D.34099>:
                    D.34101 = &MEM[(void *)"Set" + 1B];
                    D.34102 = *D.34101;
                    D.34103 = (int) D.34102;
                    D.34104 = __s2 + 1;
                    D.34105 = *D.34104;
                    D.34106 = (int) D.34105;
                    __result = D.34103 - D.34106;
                    if (__s2_len > 1) goto <D.34107>; else goto <D.34108>;
                    <D.34107>:
                    if (__result == 0) goto <D.34109>; else goto <D.34110>;
                    <D.34109>:
                    D.34111 = &MEM[(void *)"Set" + 2B];
                    D.34112 = *D.34111;
                    D.34113 = (int) D.34112;
                    D.34114 = __s2 + 2;
                    D.34115 = *D.34114;
                    D.34116 = (int) D.34115;
                    __result = D.34113 - D.34116;
                    if (__s2_len > 2) goto <D.34117>; else goto <D.34118>;
                    <D.34117>:
                    if (__result == 0) goto <D.34119>; else goto <D.34120>;
                    <D.34119>:
                    D.34121 = &MEM[(void *)"Set" + 3B];
                    D.34122 = *D.34121;
                    D.34123 = (int) D.34122;
                    D.34124 = __s2 + 3;
                    D.34125 = *D.34124;
                    D.34126 = (int) D.34125;
                    __result = D.34123 - D.34126;
                    <D.34120>:
                    <D.34118>:
                    <D.34110>:
                    <D.34108>:
                    <D.34100>:
                    <D.34098>:
                  }
                  D.28043 = __result;
                }
                iftmp.128 = -D.28043;
                goto <D.34127>;
                <D.34091>:
                D.33344 = cmethod->name;
                iftmp.128 = __builtin_strcmp (D.33344, "Set");
                <D.34127>:
                D.28044 = iftmp.128;
              }
              if (D.28044 == 0) goto <D.34128>; else goto <D.34129>;
              <D.34128>:
              {
                struct MonoInst * val;

                D.32757 = fsig->param_count;
                D.33077 = (long unsigned int) D.32757;
                D.33078 = D.33077 * 8;
                D.34130 = sp + D.33078;
                val = *D.34130;
                D.34131 = val->type;
                if (D.34131 == 6) goto <D.34132>; else goto <D.34133>;
                <D.34132>:
                {
                  struct MonoInst * iargs[2];

                  try
                    {
                      D.31957 = *sp;
                      iargs[0] = D.31957;
                      iargs[1] = val;
                      mono_emit_jit_icall (cfg, mono_helper_stelem_ref_check, &iargs);
                    }
                  finally
                    {
                      iargs = {CLOBBER};
                    }
                }
                <D.34133>:
                addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 1);
                D.30941 = cfg->mempool;
                ins = mono_mempool_alloc (D.30941, 80);
                ins->data.op[1].const_val = 0;
                D.31158 = ins->data.op[1].const_val;
                ins->data.op[0].const_val = D.31158;
                ins->prev = 0B;
                D.31159 = ins->prev;
                ins->next = D.31159;
                D.32757 = fsig->param_count;
                D.32758 = (int) D.32757;
                D.34134 = D.32758 + -1;
                D.34135 = fsig->params[D.34134];
                D.34136 = mono_type_to_store_membase (cfg, D.34135);
                D.34137 = (short unsigned int) D.34136;
                ins->opcode = D.34137;
                ins->flags = 0;
                ins->type = 0;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.31160 = ins->sreg3;
                ins->sreg2 = D.31160;
                D.31161 = ins->sreg2;
                ins->sreg1 = D.31161;
                D.31162 = cfg->ip;
                ins->cil_code = D.31162;
                D.34138 = val->dreg;
                ins->sreg1 = D.34138;
                D.34139 = addr->dreg;
                ins->dreg = D.34139;
                ins->data.op[0].const_val = 0;
                D.32757 = fsig->param_count;
                D.32758 = (int) D.32757;
                D.34134 = D.32758 + -1;
                D.34135 = fsig->params[D.34134];
                type_to_eval_stack_type (cfg, D.34135, ins);
                D.32757 = fsig->param_count;
                D.32758 = (int) D.32757;
                D.34134 = D.32758 + -1;
                D.34135 = fsig->params[D.34134];
                D.34140 = mono_class_from_mono_type (D.34135);
                ins->klass = D.34140;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.34141>; else goto <D.34142>;
                <D.34141>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = ins;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                ins->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = ins;
                goto <D.34143>;
                <D.34142>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = ins;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.34143>:
                D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.34146 = D.31336 & 1152921504606846976;
                if (D.34146 != 0) goto <D.34147>; else goto <D.34148>;
                <D.34147>:
                D.34131 = val->type;
                if (D.34131 == 6) goto <D.34149>; else goto <D.34150>;
                <D.34149>:
                D.34151 = val->opcode;
                if (D.34151 != 363) goto <D.34144>; else goto <D.34152>;
                <D.34152>:
                D.34153 = val->data.op[0].const_val;
                if (D.34153 != 0) goto <D.34144>; else goto <D.34145>;
                <D.34144>:
                emit_write_barrier (cfg, addr, val);
                <D.34145>:
                <D.34150>:
                <D.34148>:
              }
              goto <D.34154>;
              <D.34129>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = cmethod->name;
                  D.34158 = "Get";
                  D.34159 = MEM[(const unsigned char *)D.34158];
                  D.34160 = (int) D.34159;
                  D.34161 = *__s2;
                  D.34162 = (int) D.34161;
                  __result = D.34160 - D.34162;
                  {
                    if (__s2_len != 0) goto <D.34163>; else goto <D.34164>;
                    <D.34163>:
                    if (__result == 0) goto <D.34165>; else goto <D.34166>;
                    <D.34165>:
                    D.34167 = &MEM[(void *)"Get" + 1B];
                    D.34168 = *D.34167;
                    D.34169 = (int) D.34168;
                    D.34170 = __s2 + 1;
                    D.34171 = *D.34170;
                    D.34172 = (int) D.34171;
                    __result = D.34169 - D.34172;
                    if (__s2_len > 1) goto <D.34173>; else goto <D.34174>;
                    <D.34173>:
                    if (__result == 0) goto <D.34175>; else goto <D.34176>;
                    <D.34175>:
                    D.34177 = &MEM[(void *)"Get" + 2B];
                    D.34178 = *D.34177;
                    D.34179 = (int) D.34178;
                    D.34180 = __s2 + 2;
                    D.34181 = *D.34180;
                    D.34182 = (int) D.34181;
                    __result = D.34179 - D.34182;
                    if (__s2_len > 2) goto <D.34183>; else goto <D.34184>;
                    <D.34183>:
                    if (__result == 0) goto <D.34185>; else goto <D.34186>;
                    <D.34185>:
                    D.34187 = &MEM[(void *)"Get" + 3B];
                    D.34188 = *D.34187;
                    D.34189 = (int) D.34188;
                    D.34190 = __s2 + 3;
                    D.34191 = *D.34190;
                    D.34192 = (int) D.34191;
                    __result = D.34189 - D.34192;
                    <D.34186>:
                    <D.34184>:
                    <D.34176>:
                    <D.34174>:
                    <D.34166>:
                    <D.34164>:
                  }
                  D.28054 = __result;
                }
                iftmp.129 = -D.28054;
                goto <D.34193>;
                <D.34157>:
                D.33344 = cmethod->name;
                iftmp.129 = __builtin_strcmp (D.33344, "Get");
                <D.34193>:
                D.28055 = iftmp.129;
              }
              if (D.28055 == 0) goto <D.34194>; else goto <D.34195>;
              <D.34194>:
              addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              D.32915 = fsig->ret;
              D.34196 = mono_type_to_load_membase (cfg, D.32915);
              D.34197 = (short unsigned int) D.34196;
              ins->opcode = D.34197;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              ins->dreg = 0;
              D.34139 = addr->dreg;
              ins->sreg1 = D.34139;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              D.32915 = fsig->ret;
              type_to_eval_stack_type (cfg, D.32915, ins);
              D.31705 = ins->type;
              D.31706 = (<unnamed type>) D.31705;
              D.34198 = alloc_dreg (cfg, D.31706);
              D.34199 = (int) D.34198;
              ins->dreg = D.34199;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34200>; else goto <D.34201>;
              <D.34200>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.34202>;
              <D.34201>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34202>:
              goto <D.34203>;
              <D.34195>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = cmethod->name;
                  D.34207 = "Address";
                  D.34208 = MEM[(const unsigned char *)D.34207];
                  D.34209 = (int) D.34208;
                  D.34210 = *__s2;
                  D.34211 = (int) D.34210;
                  __result = D.34209 - D.34211;
                  {
                    if (__s2_len != 0) goto <D.34212>; else goto <D.34213>;
                    <D.34212>:
                    if (__result == 0) goto <D.34214>; else goto <D.34215>;
                    <D.34214>:
                    D.34216 = &MEM[(void *)"Address" + 1B];
                    D.34217 = *D.34216;
                    D.34218 = (int) D.34217;
                    D.34219 = __s2 + 1;
                    D.34220 = *D.34219;
                    D.34221 = (int) D.34220;
                    __result = D.34218 - D.34221;
                    if (__s2_len > 1) goto <D.34222>; else goto <D.34223>;
                    <D.34222>:
                    if (__result == 0) goto <D.34224>; else goto <D.34225>;
                    <D.34224>:
                    D.34226 = &MEM[(void *)"Address" + 2B];
                    D.34227 = *D.34226;
                    D.34228 = (int) D.34227;
                    D.34229 = __s2 + 2;
                    D.34230 = *D.34229;
                    D.34231 = (int) D.34230;
                    __result = D.34228 - D.34231;
                    if (__s2_len > 2) goto <D.34232>; else goto <D.34233>;
                    <D.34232>:
                    if (__result == 0) goto <D.34234>; else goto <D.34235>;
                    <D.34234>:
                    D.34236 = &MEM[(void *)"Address" + 3B];
                    D.34237 = *D.34236;
                    D.34238 = (int) D.34237;
                    D.34239 = __s2 + 3;
                    D.34240 = *D.34239;
                    D.34241 = (int) D.34240;
                    __result = D.34238 - D.34241;
                    <D.34235>:
                    <D.34233>:
                    <D.34225>:
                    <D.34223>:
                    <D.34215>:
                    <D.34213>:
                  }
                  D.28063 = __result;
                }
                iftmp.130 = -D.28063;
                goto <D.34242>;
                <D.34206>:
                D.33344 = cmethod->name;
                iftmp.130 = __builtin_strcmp (D.33344, "Address");
                <D.34242>:
                D.28064 = iftmp.130;
              }
              if (D.28064 == 0) goto <D.34243>; else goto <D.34244>;
              <D.34243>:
              D.32828 = cmethod->klass;
              D.34245 = D.32828->element_class;
              D.34246 = BIT_FIELD_REF <*D.34245, 64, 256>;
              D.34247 = D.34246 & 8;
              if (D.34247 == 0) goto <D.34248>; else goto <D.34249>;
              <D.34248>:
              if (readonly == 0) goto <D.34250>; else goto <D.34251>;
              <D.34250>:
              D.31957 = *sp;
              D.32828 = cmethod->klass;
              mini_emit_check_array_type (cfg, D.31957, D.32828);
              <D.34251>:
              <D.34249>:
              D.32828 = cmethod->klass;
              if (D.32828 == 0B) goto <D.34252>; else goto <D.34254>;
              <D.34254>:
              D.32828 = cmethod->klass;
              D.33375 = D.32828->exception_type;
              if (D.33375 != 0) goto <D.34252>; else goto <D.34253>;
              <D.34252>:
              D.32828 = cmethod->klass;
              cfg->exception_ptr = D.32828;
              D.34255 = mini_get_debug_options ();
              D.34256 = D.34255->break_on_unverified;
              if (D.34256 != 0) goto <D.34257>; else goto load_error;
              <D.34257>:
              raise (5);
              <D.34253>:
              readonly = 0;
              addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
              ins = addr;
              goto <D.34258>;
              <D.34244>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 8334);
              <D.34258>:
              <D.34203>:
              <D.34154>:
              emit_widen = 0;
              goto call_end;
            }
            <D.34088>:
            if (virtual != 0) goto <D.34260>; else goto <D.34261>;
            <D.34260>:
            iftmp.131 = *sp;
            goto <D.34262>;
            <D.34261>:
            iftmp.131 = 0B;
            <D.34262>:
            ins = mini_redirect_call (cfg, cmethod, fsig, sp, iftmp.131);
            if (ins != 0B) goto call_end; else goto <D.34263>;
            <D.34263>:
            if (cmethod != 0B) goto <D.34264>; else goto <D.34265>;
            <D.34264>:
            D.34266 = ins_flag & 4;
            if (D.34266 != 0) goto <D.34267>; else goto <D.34268>;
            <D.34267>:
            if (vtable_arg == 0B) goto <D.34269>; else goto <D.34270>;
            <D.34269>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 == 0B) goto <D.34271>; else goto <D.34272>;
            <D.34271>:
            call_opcode.132 = (int) call_opcode;
            D.34274 = is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode.132);
            if (D.34274 != 0) goto <D.34275>; else goto <D.34276>;
            <D.34275>:
            supported_tail_call = 1;
            <D.34276>:
            <D.34272>:
            <D.34270>:
            <D.34268>:
            <D.34265>:
            if (supported_tail_call != 0) goto <D.34277>; else goto <D.34278>;
            <D.34277>:
            {
              struct MonoCallInst * call;

              D.30911 = cfg->method;
              if (D.30911 != method) goto <D.34279>; else goto <D.34280>;
              <D.34279>:
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 == 0) goto <D.34281>; else goto <D.34282>;
              <D.34281>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.34283>; else goto <D.34284>;
              <D.34283>:
              printf ("inline failed: %s\n", "tail call");
              <D.34284>:
              goto inline_failure;
              <D.34282>:
              <D.34280>:
              if (1 != 0) goto <D.34285>; else goto <D.34286>;
              <D.34285>:
              tail_call = 1;
              goto <D.34287>;
              <D.34286>:
              D.30941 = cfg->mempool;
              call = mono_mempool_alloc0 (D.30941, 192);
              call->inst.opcode = 443;
              call->inst.dreg = -1;
              call->inst.sreg3 = -1;
              D.34288 = call->inst.sreg3;
              call->inst.sreg2 = D.34288;
              D.34289 = call->inst.sreg2;
              call->inst.sreg1 = D.34289;
              D.31162 = cfg->ip;
              call->inst.cil_code = D.31162;
              call->tail_call = 1;
              call->method = cmethod;
              D.34290 = mono_method_signature (cmethod);
              call->signature = D.34290;
              i = 0;
              goto <D.28067>;
              <D.28066>:
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.32727 = arg_array + D.31690;
              D.32728 = *D.32727;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.32727 = arg_array + D.31690;
              D.32728 = *D.32727;
              D.32729 = D.32728->flags;
              D.32730 = D.32729 | 4;
              D.32728->flags = D.32730;
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              D.31569 = cfg->arg_types;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.34291 = D.31569 + D.31690;
              D.34292 = *D.34291;
              D.34293 = mono_type_to_regmove (cfg, D.34292);
              D.34294 = (short unsigned int) D.34293;
              ins->opcode = D.34294;
              D.31559 = cfg->args;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.34295 = D.31559 + D.31690;
              D.34296 = *D.34295;
              D.34297 = D.34296->klass;
              ins->klass = D.34297;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.34298 = sp + D.31690;
              D.34299 = *D.34298;
              D.34300 = D.34299->dreg;
              ins->sreg1 = D.34300;
              D.31559 = cfg->args;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.34295 = D.31559 + D.31690;
              D.34296 = *D.34295;
              D.34301 = D.34296->dreg;
              ins->dreg = D.34301;
              D.31709 = ins->opcode;
              if (D.31709 == 427) goto <D.34302>; else goto <D.34303>;
              <D.34302>:
              D.31569 = cfg->arg_types;
              D.31069 = (long unsigned int) i;
              D.31690 = D.31069 * 8;
              D.34291 = D.31569 + D.31690;
              D.34292 = *D.34291;
              D.34304 = mono_class_from_mono_type (D.34292);
              ins->klass = D.34304;
              <D.34303>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34305>; else goto <D.34306>;
              <D.34305>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.34307>;
              <D.34306>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34307>:
              i = i + 1;
              <D.28067>:
              if (i < n) goto <D.28066>; else goto <D.28068>;
              <D.28068>:
              ins = call;
              ins->data.op[0].p = cmethod;
              D.31252 = *arg_array;
              ins->data.op[1].p = D.31252;
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              if (D.31279 != 0B) goto <D.34308>; else goto <D.34309>;
              <D.34308>:
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              D.31279->next = ins;
              bblock.70 = bblock;
              D.31279 = bblock.70->last_ins;
              ins->prev = D.31279;
              bblock.70 = bblock;
              bblock.70->last_ins = ins;
              goto <D.34310>;
              <D.34309>:
              bblock.70 = bblock;
              bblock.70 = bblock;
              bblock.70->last_ins = ins;
              D.31279 = bblock.70->last_ins;
              bblock.70->code = D.31279;
              <D.34310>:
              bblock.70 = bblock;
              link_bblock (cfg, bblock.70, end_bblock);
              start_new_bblock = 1;
              D.31071 = cfg->cil_offset_to_bb;
              D.32381 = ip + 5;
              D.32926 = (long int) D.32381;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.33749 = D.32926 - D.31077;
              D.33750 = (long unsigned int) D.33749;
              D.33751 = D.33750 * 8;
              D.33752 = D.31071 + D.33751;
              tblock = *D.33752;
              if (tblock == 0B) goto <D.34311>; else goto <D.34312>;
              <D.34311>:
              D.32381 = ip + 5;
              if (D.32381 >= end) goto <D.34313>; else goto <D.34315>;
              <D.34315>:
              D.33758 = ip + 5;
              D.31088 = header->code;
              if (D.33758 < D.31088) goto <D.34313>; else goto <D.34314>;
              <D.34313>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.34316>; else goto <D.34317>;
              <D.34316>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 2) goto <D.34318>; else goto <D.34319>;
              <D.34318>:
              printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
              <D.34319>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.34317>:
              D.34320 = mini_get_debug_options ();
              D.34321 = D.34320->break_on_unverified;
              if (D.34321 != 0) goto <D.34322>; else goto unverified;
              <D.34322>:
              raise (5);
              <D.34314>:
              D.30941 = cfg->mempool;
              tblock = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.34323 = D.31048;
              D.34324 = D.34323 + 1;
              cfg->num_bblocks = D.34324;
              D.34325 = (int) D.34323;
              tblock->block_num = D.34325;
              D.32381 = ip + 5;
              tblock->cil_code = D.32381;
              D.31138 = tblock->cil_code;
              if (D.31138 != 0B) goto <D.34326>; else goto <D.34327>;
              <D.34326>:
              D.31071 = cfg->cil_offset_to_bb;
              D.31138 = tblock->cil_code;
              D.31141 = (long int) D.31138;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.31142 = D.31141 - D.31077;
              D.31143 = (long unsigned int) D.31142;
              D.31144 = D.31143 * 8;
              D.31145 = D.31071 + D.31144;
              *D.31145 = tblock;
              <D.34327>:
              D.31108 = cfg->real_offset;
              tblock->real_offset = D.31108;
              <D.34312>:
              bblock.70 = bblock;
              if (tblock == bblock.70) goto <D.34328>; else goto <D.34330>;
              <D.34330>:
              D.34331 = tblock->in_count;
              if (D.34331 == 0) goto <D.34328>; else goto <D.34329>;
              <D.34328>:
              skip_ret = 1;
              <D.34329>:
              push_res = 0;
              goto call_end;
              <D.34287>:
            }
            <D.34278>:
            D.30911 = cfg->method;
            D.32877 = BIT_FIELD_REF <*D.30911, 64, 256>;
            D.32878 = D.32877 & 124;
            if (D.32878 == 64) goto <D.34332>; else goto <D.34333>;
            <D.34332>:
            {
              struct MonoMethod * orig;

              D.30911 = cfg->method;
              orig = mono_marshal_method_from_wrapper (D.30911);
              if (cmethod == orig) goto <D.34334>; else goto <D.34336>;
              <D.34336>:
              D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
              D.33571 = D.32948 & 4096;
              if (D.33571 != 0) goto <D.34337>; else goto <D.34335>;
              <D.34337>:
              D.34338 = mono_method_get_declaring_generic_method (cmethod);
              if (D.34338 == orig) goto <D.34334>; else goto <D.34335>;
              <D.34334>:
              cmethod = mono_marshal_get_synchronized_inner_wrapper (cmethod);
              <D.34335>:
            }
            <D.34333>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.34339>; else goto <D.34340>;
            <D.34339>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.34341>; else goto <D.34342>;
            <D.34341>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.34343>; else goto <D.34344>;
            <D.34343>:
            printf ("inline failed: %s\n", "call");
            <D.34344>:
            goto inline_failure;
            <D.34342>:
            <D.34340>:
            if (virtual != 0) goto <D.34346>; else goto <D.34347>;
            <D.34346>:
            iftmp.133 = *sp;
            goto <D.34348>;
            <D.34347>:
            iftmp.133 = 0B;
            <D.34348>:
            ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, iftmp.133, imt_arg, vtable_arg);
            if (tail_call != 0) goto <D.34349>; else goto <D.34350>;
            <D.34349>:
            bblock.70 = bblock;
            link_bblock (cfg, bblock.70, end_bblock);
            start_new_bblock = 1;
            D.31071 = cfg->cil_offset_to_bb;
            D.32381 = ip + 5;
            D.32926 = (long int) D.32381;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.33749 = D.32926 - D.31077;
            D.33750 = (long unsigned int) D.33749;
            D.33751 = D.33750 * 8;
            D.33752 = D.31071 + D.33751;
            tblock = *D.33752;
            if (tblock == 0B) goto <D.34351>; else goto <D.34352>;
            <D.34351>:
            D.32381 = ip + 5;
            if (D.32381 >= end) goto <D.34353>; else goto <D.34355>;
            <D.34355>:
            D.33758 = ip + 5;
            D.31088 = header->code;
            if (D.33758 < D.31088) goto <D.34353>; else goto <D.34354>;
            <D.34353>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.34356>; else goto <D.34357>;
            <D.34356>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.34358>; else goto <D.34359>;
            <D.34358>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.34359>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.34357>:
            D.34360 = mini_get_debug_options ();
            D.34361 = D.34360->break_on_unverified;
            if (D.34361 != 0) goto <D.34362>; else goto unverified;
            <D.34362>:
            raise (5);
            <D.34354>:
            D.30941 = cfg->mempool;
            tblock = mono_mempool_alloc0 (D.30941, 296);
            D.31048 = cfg->num_bblocks;
            D.34363 = D.31048;
            D.34364 = D.34363 + 1;
            cfg->num_bblocks = D.34364;
            D.34365 = (int) D.34363;
            tblock->block_num = D.34365;
            D.32381 = ip + 5;
            tblock->cil_code = D.32381;
            D.31138 = tblock->cil_code;
            if (D.31138 != 0B) goto <D.34366>; else goto <D.34367>;
            <D.34366>:
            D.31071 = cfg->cil_offset_to_bb;
            D.31138 = tblock->cil_code;
            D.31141 = (long int) D.31138;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.31142 = D.31141 - D.31077;
            D.31143 = (long unsigned int) D.31142;
            D.31144 = D.31143 * 8;
            D.31145 = D.31071 + D.31144;
            *D.31145 = tblock;
            <D.34367>:
            D.31108 = cfg->real_offset;
            tblock->real_offset = D.31108;
            <D.34352>:
            bblock.70 = bblock;
            if (tblock == bblock.70) goto <D.34368>; else goto <D.34370>;
            <D.34370>:
            D.34331 = tblock->in_count;
            if (D.34331 == 0) goto <D.34368>; else goto <D.34369>;
            <D.34368>:
            skip_ret = 1;
            <D.34369>:
            push_res = 0;
            <D.34350>:
            call_end:
            if (push_res != 0) goto <D.34371>; else goto <D.34372>;
            <D.34371>:
            D.32915 = fsig->ret;
            D.34373 = mono_type_is_void (D.32915);
            if (D.34373 == 0) goto <D.34374>; else goto <D.34375>;
            <D.34374>:
            D.34376 = ins == 0B;
            D.34377 = (long int) D.34376;
            D.34378 = __builtin_expect (D.34377, 0);
            if (D.34378 != 0) goto <D.34379>; else goto <D.34380>;
            <D.34379>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8442, "ins");
            <D.34380>:
            if (emit_widen != 0) goto <D.34381>; else goto <D.34382>;
            <D.34381>:
            sp.134 = sp;
            sp = sp.134 + 8;
            D.34384 = mono_emit_widen_call_res (cfg, ins, fsig);
            *sp.134 = D.34384;
            goto <D.34385>;
            <D.34382>:
            sp.135 = sp;
            sp = sp.135 + 8;
            *sp.135 = ins;
            <D.34385>:
            <D.34375>:
            <D.34372>:
            if (keep_this_alive != 0B) goto <D.34387>; else goto <D.34388>;
            <D.34387>:
            {
              struct MonoInst * dummy_use;

              D.30941 = cfg->mempool;
              dummy_use = mono_mempool_alloc (D.30941, 80);
              dummy_use->data.op[1].const_val = 0;
              D.34389 = dummy_use->data.op[1].const_val;
              dummy_use->data.op[0].const_val = D.34389;
              dummy_use->prev = 0B;
              D.34390 = dummy_use->prev;
              dummy_use->next = D.34390;
              dummy_use->opcode = 796;
              dummy_use->flags = 0;
              dummy_use->type = 0;
              dummy_use->dreg = -1;
              dummy_use->sreg3 = -1;
              D.34391 = dummy_use->sreg3;
              dummy_use->sreg2 = D.34391;
              D.34392 = dummy_use->sreg2;
              dummy_use->sreg1 = D.34392;
              D.31162 = cfg->ip;
              dummy_use->cil_code = D.31162;
              D.34393 = keep_this_alive->dreg;
              dummy_use->sreg1 = D.34393;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.34394>; else goto <D.34395>;
              <D.34394>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = dummy_use;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              dummy_use->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = dummy_use;
              goto <D.34396>;
              <D.34395>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = dummy_use;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.34396>:
            }
            <D.34388>:
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.34397>;
            <D.34397>:
            ip = ip + 5;
            if (skip_ret != 0) goto <D.34398>; else goto <D.34399>;
            <D.34398>:
            D.31838 = *ip;
            D.34400 = D.31838 != 42;
            D.34401 = (long int) D.34400;
            D.34402 = __builtin_expect (D.34401, 0);
            if (D.34402 != 0) goto <D.34403>; else goto <D.34404>;
            <D.34403>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8460, "*ip == CEE_RET");
            <D.34404>:
            ip = ip + 1;
            <D.34399>:
            ins_flag = 0;
            constrained_call = 0B;
            if (need_seq_point != 0) goto <D.34405>; else goto <D.34406>;
            <D.34405>:
            emit_seq_point (cfg, method, ip, 0, 1);
            <D.34406>:
            goto <D.27857>;
          }
        finally
          {
            pass_vtable = {CLOBBER};
            pass_mrgctx = {CLOBBER};
          }
      }
      <D.28071>:
      D.30911 = cfg->method;
      if (D.30911 != method) goto <D.34407>; else goto <D.34408>;
      <D.34407>:
      if (return_var != 0B) goto <D.34409>; else goto <D.34410>;
      <D.34409>:
      bblock.113 = cfg->cbb;
      D.34411 = bblock.113->in_count;
      if (D.34411 != 0) goto <D.34412>; else goto <D.34413>;
      <D.34412>:
      {
        struct MonoType * ret_type;
        struct MonoInst * store;

        D.34414 = mono_method_signature (method);
        ret_type = D.34414->ret;
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.34415>; else goto <D.34416>;
        <D.34415>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34417>; else goto <D.34418>;
        <D.34417>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34419>; else goto <D.34420>;
        <D.34419>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34420>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34418>:
        D.34421 = mini_get_debug_options ();
        D.34422 = D.34421->break_on_unverified;
        if (D.34422 != 0) goto <D.34423>; else goto unverified;
        <D.34423>:
        raise (5);
        <D.34416>:
        sp = sp + 18446744073709551608;
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 == 68) goto <D.34424>; else goto <D.34426>;
        <D.34426>:
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 == 0) goto <D.34424>; else goto <D.34425>;
        <D.34424>:
        D.31957 = *sp;
        D.34427 = target_type_is_incompatible (cfg, ret_type, D.31957);
        if (D.34427 != 0) goto <D.34428>; else goto <D.34429>;
        <D.34428>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34430>; else goto <D.34431>;
        <D.34430>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34432>; else goto <D.34433>;
        <D.34432>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34433>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34431>:
        D.34434 = mini_get_debug_options ();
        D.34435 = D.34434->break_on_unverified;
        if (D.34435 != 0) goto <D.34436>; else goto unverified;
        <D.34436>:
        raise (5);
        <D.34429>:
        <D.34425>:
        D.30941 = cfg->mempool;
        store = mono_mempool_alloc (D.30941, 80);
        store->data.op[1].const_val = 0;
        D.34437 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.34437;
        store->prev = 0B;
        D.34438 = store->prev;
        store->next = D.34438;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.34439 = store->sreg3;
        store->sreg2 = D.34439;
        D.34440 = store->sreg2;
        store->sreg1 = D.34440;
        D.31162 = cfg->ip;
        store->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.34441 = return_var->data.op[0].const_val;
        D.34442 = (long unsigned int) D.34441;
        D.34443 = D.34442 * 8;
        D.34444 = D.31695 + D.34443;
        D.34445 = *D.34444;
        D.34446 = D.34445->data.op[1].vtype;
        D.34447 = mono_type_to_regmove (cfg, D.34446);
        D.34448 = (short unsigned int) D.34447;
        store->opcode = D.34448;
        D.31695 = cfg->varinfo;
        D.34441 = return_var->data.op[0].const_val;
        D.34442 = (long unsigned int) D.34441;
        D.34443 = D.34442 * 8;
        D.34444 = D.31695 + D.34443;
        D.34445 = *D.34444;
        D.34449 = D.34445->klass;
        store->klass = D.34449;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        store->sreg1 = D.32139;
        D.31695 = cfg->varinfo;
        D.34441 = return_var->data.op[0].const_val;
        D.34442 = (long unsigned int) D.34441;
        D.34443 = D.34442 * 8;
        D.34444 = D.31695 + D.34443;
        D.34445 = *D.34444;
        D.34450 = D.34445->dreg;
        store->dreg = D.34450;
        D.34451 = store->opcode;
        if (D.34451 == 427) goto <D.34452>; else goto <D.34453>;
        <D.34452>:
        D.31695 = cfg->varinfo;
        D.34441 = return_var->data.op[0].const_val;
        D.34442 = (long unsigned int) D.34441;
        D.34443 = D.34442 * 8;
        D.34444 = D.31695 + D.34443;
        D.34445 = *D.34444;
        D.34446 = D.34445->data.op[1].vtype;
        D.34454 = mono_class_from_mono_type (D.34446);
        store->klass = D.34454;
        <D.34453>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.34455>; else goto <D.34456>;
        <D.34455>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = store;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        store->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        goto <D.34457>;
        <D.34456>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.34457>:
        cfg->ret_var_set = 1;
      }
      <D.34413>:
      <D.34410>:
      goto <D.34458>;
      <D.34408>:
      D.34459 = cfg->lmf_var;
      if (D.34459 != 0B) goto <D.34460>; else goto <D.34461>;
      <D.34460>:
      bblock.113 = cfg->cbb;
      D.34411 = bblock.113->in_count;
      if (D.34411 != 0) goto <D.34462>; else goto <D.34463>;
      <D.34462>:
      emit_pop_lmf (cfg);
      <D.34463>:
      <D.34461>:
      D.34464 = cfg->ret;
      if (D.34464 != 0B) goto <D.34465>; else goto <D.34466>;
      <D.34465>:
      {
        struct MonoType * ret_type;

        D.34467 = mono_method_signature (method);
        D.34468 = D.34467->ret;
        ret_type = mini_replace_type (D.34468);
        if (seq_points != 0) goto <D.34469>; else goto <D.34470>;
        <D.34469>:
        if (sym_seq_points == 0) goto <D.34471>; else goto <D.34472>;
        <D.34471>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        ins->data.op[1].const_val = D.31651;
        ins->flags = 1;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.34473>; else goto <D.34474>;
        <D.34473>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.34475>;
        <D.34474>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.34475>:
        <D.34472>:
        <D.34470>:
        D.34476 = return_var != 0B;
        D.34477 = (long int) D.34476;
        D.34478 = __builtin_expect (D.34477, 0);
        if (D.34478 != 0) goto <D.34479>; else goto <D.34480>;
        <D.34479>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8511, "!return_var");
        <D.34480>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.34481>; else goto <D.34482>;
        <D.34481>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34483>; else goto <D.34484>;
        <D.34483>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34485>; else goto <D.34486>;
        <D.34485>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34486>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34484>:
        D.34487 = mini_get_debug_options ();
        D.34488 = D.34487->break_on_unverified;
        if (D.34488 != 0) goto <D.34489>; else goto unverified;
        <D.34489>:
        raise (5);
        <D.34482>:
        sp = sp + 18446744073709551608;
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 == 68) goto <D.34490>; else goto <D.34492>;
        <D.34492>:
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 == 0) goto <D.34490>; else goto <D.34491>;
        <D.34490>:
        D.31957 = *sp;
        D.34493 = target_type_is_incompatible (cfg, ret_type, D.31957);
        if (D.34493 != 0) goto <D.34494>; else goto <D.34495>;
        <D.34494>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34496>; else goto <D.34497>;
        <D.34496>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34498>; else goto <D.34499>;
        <D.34498>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34499>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34497>:
        D.34500 = mini_get_debug_options ();
        D.34501 = D.34500->break_on_unverified;
        if (D.34501 != 0) goto <D.34502>; else goto unverified;
        <D.34502>:
        raise (5);
        <D.34495>:
        <D.34491>:
        D.34503 = mini_type_to_stind (cfg, ret_type);
        if (D.34503 == 129) goto <D.34504>; else goto <D.34505>;
        <D.34504>:
        {
          struct MonoInst * ret_addr;

          D.34506 = cfg->vret_addr;
          if (D.34506 == 0B) goto <D.34507>; else goto <D.34508>;
          <D.34507>:
          {
            struct MonoInst * ins;

            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.34509 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.34509;
            ins->prev = 0B;
            D.34510 = ins->prev;
            ins->next = D.34510;
            ins->opcode = 424;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.34511 = ins->sreg3;
            ins->sreg2 = D.34511;
            D.34512 = ins->sreg2;
            ins->sreg1 = D.34512;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.34513 = mono_type_to_regmove (cfg, ret_type);
            D.34514 = (short unsigned int) D.34513;
            ins->opcode = D.34514;
            D.34464 = cfg->ret;
            D.34515 = D.34464->klass;
            ins->klass = D.34515;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ins->sreg1 = D.32139;
            D.34464 = cfg->ret;
            D.34516 = D.34464->dreg;
            ins->dreg = D.34516;
            D.34517 = ins->opcode;
            if (D.34517 == 427) goto <D.34518>; else goto <D.34519>;
            <D.34518>:
            D.34520 = mono_class_from_mono_type (ret_type);
            ins->klass = D.34520;
            <D.34519>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.34521>; else goto <D.34522>;
            <D.34521>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.34523>;
            <D.34522>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.34523>:
          }
          goto <D.34524>;
          <D.34508>:
          D.30941 = cfg->mempool;
          ret_addr = mono_mempool_alloc (D.30941, 80);
          ret_addr->data.op[1].const_val = 0;
          D.34525 = ret_addr->data.op[1].const_val;
          ret_addr->data.op[0].const_val = D.34525;
          ret_addr->prev = 0B;
          D.34526 = ret_addr->prev;
          ret_addr->next = D.34526;
          ret_addr->opcode = 424;
          ret_addr->flags = 0;
          ret_addr->type = 0;
          ret_addr->dreg = -1;
          ret_addr->sreg3 = -1;
          D.34527 = ret_addr->sreg3;
          ret_addr->sreg2 = D.34527;
          D.34528 = ret_addr->sreg2;
          ret_addr->sreg1 = D.34528;
          D.31162 = cfg->ip;
          ret_addr->cil_code = D.31162;
          ret_addr->type = 5;
          D.34464 = cfg->ret;
          D.34515 = D.34464->klass;
          ret_addr->klass = D.34515;
          D.34506 = cfg->vret_addr;
          D.34529 = D.34506->dreg;
          ret_addr->sreg1 = D.34529;
          D.34530 = ret_addr->type;
          D.34531 = (<unnamed type>) D.34530;
          D.34532 = alloc_dreg (cfg, D.34531);
          D.34533 = (int) D.34532;
          ret_addr->dreg = D.34533;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.34534>; else goto <D.34535>;
          <D.34534>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ret_addr;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ret_addr->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ret_addr;
          goto <D.34536>;
          <D.34535>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ret_addr;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.34536>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 387;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          ins->sreg1 = D.32139;
          D.34537 = ret_addr->dreg;
          ins->dreg = D.34537;
          ins->data.op[0].const_val = 0;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.34538>; else goto <D.34539>;
          <D.34538>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.34540>;
          <D.34539>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.34540>:
          D.34541 = mono_class_from_mono_type (ret_type);
          ins->klass = D.34541;
          <D.34524>:
        }
        goto <D.34542>;
        <D.34505>:
        D.31957 = *sp;
        mono_arch_emit_setret (cfg, method, D.31957);
        <D.34542>:
      }
      <D.34466>:
      <D.34458>:
      if (sp != stack_start) goto <D.34543>; else goto <D.34544>;
      <D.34543>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34545>; else goto <D.34546>;
      <D.34545>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34547>; else goto <D.34548>;
      <D.34547>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34548>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34546>:
      D.34549 = mini_get_debug_options ();
      D.34550 = D.34549->break_on_unverified;
      if (D.34550 != 0) goto <D.34551>; else goto unverified;
      <D.34551>:
      raise (5);
      <D.34544>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip = ip + 1;
      ins->data.op[0].target_block = end_bblock;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.34552>; else goto <D.34553>;
      <D.34552>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.34554>;
      <D.34553>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.34554>:
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, end_bblock);
      start_new_bblock = 1;
      goto <D.27857>;
      <D.28077>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.34555>; else goto <D.34556>;
      <D.34555>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34557>; else goto <D.34558>;
      <D.34557>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 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.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip = ip + 1;
      D.31838 = *ip;
      D.34564 = (signed char) D.31838;
      D.34565 = (sizetype) D.34564;
      D.34566 = D.34565 + 1;
      target = ip + D.34566;
      ip = ip + 1;
      D.31071 = cfg->cil_offset_to_bb;
      target.136 = (long int) target;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.34568 = target.136 - D.31077;
      D.34569 = (long unsigned int) D.34568;
      D.34570 = D.34569 * 8;
      D.34571 = D.31071 + D.34570;
      tblock = *D.34571;
      if (tblock == 0B) goto <D.34572>; else goto <D.34573>;
      <D.34572>:
      if (target >= end) goto <D.34574>; else goto <D.34576>;
      <D.34576>:
      D.31088 = header->code;
      if (D.31088 > target) goto <D.34574>; else goto <D.34575>;
      <D.34574>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34577>; else goto <D.34578>;
      <D.34577>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34579>; else goto <D.34580>;
      <D.34579>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34580>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34578>:
      D.34581 = mini_get_debug_options ();
      D.34582 = D.34581->break_on_unverified;
      if (D.34582 != 0) goto <D.34583>; else goto unverified;
      <D.34583>:
      raise (5);
      <D.34575>:
      D.30941 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.34584 = D.31048;
      D.34585 = D.34584 + 1;
      cfg->num_bblocks = D.34585;
      D.34586 = (int) D.34584;
      tblock->block_num = D.34586;
      tblock->cil_code = target;
      D.31138 = tblock->cil_code;
      if (D.31138 != 0B) goto <D.34587>; else goto <D.34588>;
      <D.34587>:
      D.31071 = cfg->cil_offset_to_bb;
      D.31138 = tblock->cil_code;
      D.31141 = (long int) D.31138;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31142 = D.31141 - D.31077;
      D.31143 = (long unsigned int) D.31142;
      D.31144 = D.31143 * 8;
      D.31145 = D.31071 + D.31144;
      *D.31145 = tblock;
      <D.34588>:
      D.31108 = cfg->real_offset;
      tblock->real_offset = D.31108;
      <D.34573>:
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, tblock);
      ins->data.op[0].target_block = tblock;
      if (sp != stack_start) goto <D.34589>; else goto <D.34590>;
      <D.34589>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31732 = (int) D.31731;
      handle_stack_args (cfg, stack_start, D.31732);
      sp = stack_start;
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31733 = D.31336 & 35184372088832;
      if (D.31733 != 0) goto <D.34591>; else goto <D.34592>;
      <D.34591>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34593>; else goto <D.34594>;
      <D.34593>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34595>; else goto <D.34596>;
      <D.34595>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34596>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34594>:
      D.34597 = mini_get_debug_options ();
      D.34598 = D.34597->break_on_unverified;
      if (D.34598 != 0) goto <D.34599>; else goto unverified;
      <D.34599>:
      raise (5);
      <D.34592>:
      <D.34590>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.34600>; else goto <D.34601>;
      <D.34600>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.34602>;
      <D.34601>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.34602>:
      start_new_bblock = 1;
      inline_costs = inline_costs + 10;
      goto <D.27857>;
      <D.28078>:
      <D.28079>:
      <D.28080>:
      <D.28081>:
      <D.28082>:
      <D.28083>:
      <D.28084>:
      <D.28085>:
      <D.28086>:
      <D.28087>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.34603>; else goto <D.34604>;
      <D.34603>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34605>; else goto <D.34606>;
      <D.34605>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34607>; else goto <D.34608>;
      <D.34607>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34608>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34606>:
      D.34609 = mini_get_debug_options ();
      D.34610 = D.34609->break_on_unverified;
      if (D.34610 != 0) goto <D.34611>; else goto unverified;
      <D.34611>:
      raise (5);
      <D.34604>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.34612>; else goto <D.34613>;
      <D.34612>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34614>; else goto <D.34615>;
      <D.34614>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34616>; else goto <D.34617>;
      <D.34616>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34617>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34615>:
      D.34618 = mini_get_debug_options ();
      D.34619 = D.34618->break_on_unverified;
      if (D.34619 != 0) goto <D.34620>; else goto unverified;
      <D.34620>:
      raise (5);
      <D.34613>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      D.34622 = D.34621 + 13;
      ins->opcode = D.34622;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip = ip + 1;
      D.32373 = MEM[(signed char *)ip];
      D.34623 = (sizetype) D.32373;
      D.34624 = D.34623 + 1;
      target = ip + D.34624;
      ip = ip + 1;
      {
        struct MonoInst * cmp;

        sp = sp + 18446744073709551600;
        D.30941 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30941, 80);
        cmp->data.op[1].const_val = 0;
        D.34625 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.34625;
        cmp->prev = 0B;
        D.34626 = cmp->prev;
        cmp->next = D.34626;
        cmp->opcode = 322;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.34627 = cmp->sreg3;
        cmp->sreg2 = D.34627;
        D.34628 = cmp->sreg2;
        cmp->sreg1 = D.34628;
        D.31162 = cfg->ip;
        cmp->cil_code = D.31162;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        cmp->sreg1 = D.32139;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        cmp->sreg2 = D.33091;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (cmp, D.31957, D.33090);
        D.34629 = cmp->type;
        if (D.34629 == 0) goto <D.34630>; else goto <D.34631>;
        <D.34630>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34632>; else goto <D.34633>;
        <D.34632>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 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.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (ins, D.31957, D.33090);
        D.30941 = cfg->mempool;
        D.34639 = mono_mempool_alloc (D.30941, 16);
        ins->data.op[1].many_blocks = D.34639;
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        tblock = *D.34571;
        if (tblock == 0B) goto <D.34640>; else goto <D.34641>;
        <D.34640>:
        if (target >= end) goto <D.34642>; else goto <D.34644>;
        <D.34644>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.34642>; else goto <D.34643>;
        <D.34642>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34645>; else goto <D.34646>;
        <D.34645>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34647>; else goto <D.34648>;
        <D.34647>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34648>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34646>:
        D.34649 = mini_get_debug_options ();
        D.34650 = D.34649->break_on_unverified;
        if (D.34650 != 0) goto <D.34651>; else goto unverified;
        <D.34651>:
        raise (5);
        <D.34643>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34652 = D.31048;
        D.34653 = D.34652 + 1;
        cfg->num_bblocks = D.34653;
        D.34654 = (int) D.34652;
        tblock->block_num = D.34654;
        tblock->cil_code = target;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34655>; else goto <D.34656>;
        <D.34655>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34656>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34641>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        D.34657 = ins->data.op[1].many_blocks;
        *D.34657 = tblock;
        if (0 != 0) goto <D.34658>; else goto <D.34659>;
        <D.34658>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, 0B);
        D.34657 = ins->data.op[1].many_blocks;
        D.34660 = D.34657 + 8;
        *D.34660 = 0B;
        start_new_bblock = 1;
        goto <D.34661>;
        <D.34659>:
        D.31071 = cfg->cil_offset_to_bb;
        ip.75 = (long int) ip;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31666 = ip.75 - D.31077;
        D.31667 = (long unsigned int) D.31666;
        D.31668 = D.31667 * 8;
        D.31669 = D.31071 + D.31668;
        tblock = *D.31669;
        if (tblock == 0B) goto <D.34662>; else goto <D.34663>;
        <D.34662>:
        if (ip >= end) goto <D.34664>; else goto <D.34666>;
        <D.34666>:
        D.31088 = header->code;
        if (D.31088 > ip) goto <D.34664>; else goto <D.34665>;
        <D.34664>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34667>; else goto <D.34668>;
        <D.34667>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34669>; else goto <D.34670>;
        <D.34669>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34670>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34668>:
        D.34671 = mini_get_debug_options ();
        D.34672 = D.34671->break_on_unverified;
        if (D.34672 != 0) goto <D.34673>; else goto unverified;
        <D.34673>:
        raise (5);
        <D.34665>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34674 = D.31048;
        D.34675 = D.34674 + 1;
        cfg->num_bblocks = D.34675;
        D.34676 = (int) D.34674;
        tblock->block_num = D.34676;
        tblock->cil_code = ip;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34677>; else goto <D.34678>;
        <D.34677>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34678>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34663>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        D.34657 = ins->data.op[1].many_blocks;
        D.34660 = D.34657 + 8;
        *D.34660 = tblock;
        start_new_bblock = 2;
        <D.34661>:
        if (sp != stack_start) goto <D.34679>; else goto <D.34680>;
        <D.34679>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31732 = (int) D.31731;
        handle_stack_args (cfg, stack_start, D.31732);
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31733 = D.31336 & 35184372088832;
        if (D.31733 != 0) goto <D.34681>; else goto <D.34682>;
        <D.34681>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34683>; else goto <D.34684>;
        <D.34683>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34685>; else goto <D.34686>;
        <D.34685>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34686>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34684>:
        D.34687 = mini_get_debug_options ();
        D.34688 = D.34687->break_on_unverified;
        if (D.34688 != 0) goto <D.34689>; else goto unverified;
        <D.34689>:
        raise (5);
        <D.34682>:
        <D.34680>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34690>; else goto <D.34691>;
        <D.34690>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = cmp;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        cmp->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        goto <D.34692>;
        <D.34691>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34692>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34693>; else goto <D.34694>;
        <D.34693>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.34695>;
        <D.34694>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34695>:
      }
      sp = stack_start;
      inline_costs = inline_costs + 10;
      goto <D.27857>;
      <D.28089>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.34696>; else goto <D.34697>;
      <D.34696>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34698>; else goto <D.34699>;
      <D.34698>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34700>; else goto <D.34701>;
      <D.34700>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34701>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34699>:
      D.34702 = mini_get_debug_options ();
      D.34703 = D.34702->break_on_unverified;
      if (D.34703 != 0) goto <D.34704>; else goto unverified;
      <D.34704>:
      raise (5);
      <D.34697>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip = ip + 1;
      D.32491 = MEM[(const guint32 *)ip];
      D.34705 = (int) D.32491;
      D.34706 = (sizetype) D.34705;
      D.34707 = D.34706 + 4;
      target = ip + D.34707;
      ip = ip + 4;
      D.31071 = cfg->cil_offset_to_bb;
      target.136 = (long int) target;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.34568 = target.136 - D.31077;
      D.34569 = (long unsigned int) D.34568;
      D.34570 = D.34569 * 8;
      D.34571 = D.31071 + D.34570;
      tblock = *D.34571;
      if (tblock == 0B) goto <D.34708>; else goto <D.34709>;
      <D.34708>:
      if (target >= end) goto <D.34710>; else goto <D.34712>;
      <D.34712>:
      D.31088 = header->code;
      if (D.31088 > target) goto <D.34710>; else goto <D.34711>;
      <D.34710>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34713>; else goto <D.34714>;
      <D.34713>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34715>; else goto <D.34716>;
      <D.34715>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34716>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34714>:
      D.34717 = mini_get_debug_options ();
      D.34718 = D.34717->break_on_unverified;
      if (D.34718 != 0) goto <D.34719>; else goto unverified;
      <D.34719>:
      raise (5);
      <D.34711>:
      D.30941 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30941, 296);
      D.31048 = cfg->num_bblocks;
      D.34720 = D.31048;
      D.34721 = D.34720 + 1;
      cfg->num_bblocks = D.34721;
      D.34722 = (int) D.34720;
      tblock->block_num = D.34722;
      tblock->cil_code = target;
      D.31138 = tblock->cil_code;
      if (D.31138 != 0B) goto <D.34723>; else goto <D.34724>;
      <D.34723>:
      D.31071 = cfg->cil_offset_to_bb;
      D.31138 = tblock->cil_code;
      D.31141 = (long int) D.31138;
      D.31076 = cfg->cil_start;
      D.31077 = (long int) D.31076;
      D.31142 = D.31141 - D.31077;
      D.31143 = (long unsigned int) D.31142;
      D.31144 = D.31143 * 8;
      D.31145 = D.31071 + D.31144;
      *D.31145 = tblock;
      <D.34724>:
      D.31108 = cfg->real_offset;
      tblock->real_offset = D.31108;
      <D.34709>:
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, tblock);
      ins->data.op[0].target_block = tblock;
      if (sp != stack_start) goto <D.34725>; else goto <D.34726>;
      <D.34725>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31732 = (int) D.31731;
      handle_stack_args (cfg, stack_start, D.31732);
      sp = stack_start;
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31733 = D.31336 & 35184372088832;
      if (D.31733 != 0) goto <D.34727>; else goto <D.34728>;
      <D.34727>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34729>; else goto <D.34730>;
      <D.34729>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34731>; else goto <D.34732>;
      <D.34731>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34732>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34730>:
      D.34733 = mini_get_debug_options ();
      D.34734 = D.34733->break_on_unverified;
      if (D.34734 != 0) goto <D.34735>; else goto unverified;
      <D.34735>:
      raise (5);
      <D.34728>:
      <D.34726>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.34736>; else goto <D.34737>;
      <D.34736>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.34738>;
      <D.34737>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.34738>:
      start_new_bblock = 1;
      inline_costs = inline_costs + 10;
      goto <D.27857>;
      <D.28090>:
      <D.28091>:
      <D.28092>:
      <D.28093>:
      {
        struct MonoInst * cmp;
        gboolean is_short;
        gboolean is_true;
        guint32 opsize;

        D.31838 = *ip;
        D.34739 = D.31838 + 212;
        D.34740 = D.34739 <= 1;
        is_short = (gboolean) D.34740;
        D.31838 = *ip;
        if (D.31838 == 45) goto <D.34742>; else goto <D.34745>;
        <D.34745>:
        D.31838 = *ip;
        if (D.31838 == 58) goto <D.34742>; else goto <D.34743>;
        <D.34742>:
        iftmp.137 = 1;
        goto <D.34744>;
        <D.34743>:
        iftmp.137 = 0;
        <D.34744>:
        is_true = iftmp.137;
        if (is_short != 0) goto <D.34747>; else goto <D.34748>;
        <D.34747>:
        iftmp.138 = 1;
        goto <D.34749>;
        <D.34748>:
        iftmp.138 = 4;
        <D.34749>:
        opsize = iftmp.138;
        D.34750 = (sizetype) opsize;
        D.34751 = ip + D.34750;
        if (D.34751 > end) goto <D.34752>; else goto <D.34753>;
        <D.34752>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34754>; else goto <D.34755>;
        <D.34754>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34756>; else goto <D.34757>;
        <D.34756>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34757>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34755>:
        D.34758 = mini_get_debug_options ();
        D.34759 = D.34758->break_on_unverified;
        if (D.34759 != 0) goto <D.34760>; else goto unverified;
        <D.34760>:
        raise (5);
        <D.34753>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.34761>; else goto <D.34762>;
        <D.34761>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34763>; else goto <D.34764>;
        <D.34763>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34765>; else goto <D.34766>;
        <D.34765>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34766>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34764>:
        D.34767 = mini_get_debug_options ();
        D.34768 = D.34767->break_on_unverified;
        if (D.34768 != 0) goto <D.34769>; else goto unverified;
        <D.34769>:
        raise (5);
        <D.34762>:
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.34774 = D.34773->type;
        if (D.34774 == 7) goto <D.34770>; else goto <D.34775>;
        <D.34775>:
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.34774 = D.34773->type;
        if (D.34774 == 4) goto <D.34770>; else goto <D.34771>;
        <D.34770>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34776>; else goto <D.34777>;
        <D.34776>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34778>; else goto <D.34779>;
        <D.34778>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34779>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34777>:
        D.34780 = mini_get_debug_options ();
        D.34781 = D.34780->break_on_unverified;
        if (D.34781 != 0) goto <D.34782>; else goto unverified;
        <D.34782>:
        raise (5);
        <D.34771>:
        ip = ip + 1;
        D.34750 = (sizetype) opsize;
        if (is_short != 0) goto <D.34784>; else goto <D.34785>;
        <D.34784>:
        D.32373 = MEM[(signed char *)ip];
        iftmp.139 = (sizetype) D.32373;
        goto <D.34786>;
        <D.34785>:
        D.32491 = MEM[(const guint32 *)ip];
        D.34705 = (int) D.32491;
        iftmp.139 = (sizetype) D.34705;
        <D.34786>:
        D.34787 = D.34750 + iftmp.139;
        target = ip + D.34787;
        D.34750 = (sizetype) opsize;
        ip = ip + D.34750;
        sp = sp + 18446744073709551608;
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        tblock = *D.34571;
        if (tblock == 0B) goto <D.34788>; else goto <D.34789>;
        <D.34788>:
        if (target >= end) goto <D.34790>; else goto <D.34792>;
        <D.34792>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.34790>; else goto <D.34791>;
        <D.34790>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34793>; else goto <D.34794>;
        <D.34793>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34795>; else goto <D.34796>;
        <D.34795>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34796>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34794>:
        D.34797 = mini_get_debug_options ();
        D.34798 = D.34797->break_on_unverified;
        if (D.34798 != 0) goto <D.34799>; else goto unverified;
        <D.34799>:
        raise (5);
        <D.34791>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34800 = D.31048;
        D.34801 = D.34800 + 1;
        cfg->num_bblocks = D.34801;
        D.34802 = (int) D.34800;
        tblock->block_num = D.34802;
        tblock->cil_code = target;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34803>; else goto <D.34804>;
        <D.34803>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34804>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34789>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        D.31071 = cfg->cil_offset_to_bb;
        ip.75 = (long int) ip;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31666 = ip.75 - D.31077;
        D.31667 = (long unsigned int) D.31666;
        D.31668 = D.31667 * 8;
        D.31669 = D.31071 + D.31668;
        tblock = *D.31669;
        if (tblock == 0B) goto <D.34805>; else goto <D.34806>;
        <D.34805>:
        if (ip >= end) goto <D.34807>; else goto <D.34809>;
        <D.34809>:
        D.31088 = header->code;
        if (D.31088 > ip) goto <D.34807>; else goto <D.34808>;
        <D.34807>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34810>; else goto <D.34811>;
        <D.34810>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34812>; else goto <D.34813>;
        <D.34812>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34813>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34811>:
        D.34814 = mini_get_debug_options ();
        D.34815 = D.34814->break_on_unverified;
        if (D.34815 != 0) goto <D.34816>; else goto unverified;
        <D.34816>:
        raise (5);
        <D.34808>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34817 = D.31048;
        D.34818 = D.34817 + 1;
        cfg->num_bblocks = D.34818;
        D.34819 = (int) D.34817;
        tblock->block_num = D.34819;
        tblock->cil_code = ip;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34820>; else goto <D.34821>;
        <D.34820>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34821>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34806>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        if (sp != stack_start) goto <D.34822>; else goto <D.34823>;
        <D.34822>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31732 = (int) D.31731;
        handle_stack_args (cfg, stack_start, D.31732);
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31733 = D.31336 & 35184372088832;
        if (D.31733 != 0) goto <D.34824>; else goto <D.34825>;
        <D.34824>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34826>; else goto <D.34827>;
        <D.34826>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34828>; else goto <D.34829>;
        <D.34828>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34829>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34827>:
        D.34830 = mini_get_debug_options ();
        D.34831 = D.34830->break_on_unverified;
        if (D.34831 != 0) goto <D.34832>; else goto unverified;
        <D.34832>:
        raise (5);
        <D.34825>:
        <D.34823>:
        D.30941 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30941, 80);
        cmp->data.op[1].const_val = 0;
        D.34833 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.34833;
        cmp->prev = 0B;
        D.34834 = cmp->prev;
        cmp->next = D.34834;
        cmp->opcode = 327;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.34835 = cmp->sreg3;
        cmp->sreg2 = D.34835;
        D.34836 = cmp->sreg2;
        cmp->sreg1 = D.34836;
        D.31162 = cfg->ip;
        cmp->cil_code = D.31162;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        cmp->sreg1 = D.32139;
        D.31957 = *sp;
        type_from_op (cmp, D.31957, 0B);
        D.34837 = cmp->type;
        if (D.34837 == 0) goto <D.34838>; else goto <D.34839>;
        <D.34838>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34840>; else goto <D.34841>;
        <D.34840>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34842>; else goto <D.34843>;
        <D.34842>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34843>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34841>:
        D.34844 = mini_get_debug_options ();
        D.34845 = D.34844->break_on_unverified;
        if (D.34845 != 0) goto <D.34846>; else goto unverified;
        <D.34846>:
        raise (5);
        <D.34839>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34847>; else goto <D.34848>;
        <D.34847>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = cmp;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        cmp->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        goto <D.34849>;
        <D.34848>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34849>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        if (is_true != 0) goto <D.34851>; else goto <D.34852>;
        <D.34851>:
        iftmp.140 = 64;
        goto <D.34853>;
        <D.34852>:
        iftmp.140 = 59;
        <D.34853>:
        ins->opcode = iftmp.140;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31957 = *sp;
        type_from_op (ins, D.31957, 0B);
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34854>; else goto <D.34855>;
        <D.34854>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.34856>;
        <D.34855>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34856>:
        D.30941 = cfg->mempool;
        D.34857 = mono_mempool_alloc (D.30941, 16);
        ins->data.op[1].many_blocks = D.34857;
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        tblock = *D.34571;
        if (tblock == 0B) goto <D.34858>; else goto <D.34859>;
        <D.34858>:
        if (target >= end) goto <D.34860>; else goto <D.34862>;
        <D.34862>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.34860>; else goto <D.34861>;
        <D.34860>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34863>; else goto <D.34864>;
        <D.34863>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34865>; else goto <D.34866>;
        <D.34865>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34866>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34864>:
        D.34867 = mini_get_debug_options ();
        D.34868 = D.34867->break_on_unverified;
        if (D.34868 != 0) goto <D.34869>; else goto unverified;
        <D.34869>:
        raise (5);
        <D.34861>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34870 = D.31048;
        D.34871 = D.34870 + 1;
        cfg->num_bblocks = D.34871;
        D.34872 = (int) D.34870;
        tblock->block_num = D.34872;
        tblock->cil_code = target;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34873>; else goto <D.34874>;
        <D.34873>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34874>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34859>:
        D.34657 = ins->data.op[1].many_blocks;
        *D.34657 = tblock;
        D.31071 = cfg->cil_offset_to_bb;
        ip.75 = (long int) ip;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31666 = ip.75 - D.31077;
        D.31667 = (long unsigned int) D.31666;
        D.31668 = D.31667 * 8;
        D.31669 = D.31071 + D.31668;
        tblock = *D.31669;
        if (tblock == 0B) goto <D.34875>; else goto <D.34876>;
        <D.34875>:
        if (ip >= end) goto <D.34877>; else goto <D.34879>;
        <D.34879>:
        D.31088 = header->code;
        if (D.31088 > ip) goto <D.34877>; else goto <D.34878>;
        <D.34877>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34880>; else goto <D.34881>;
        <D.34880>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34882>; else goto <D.34883>;
        <D.34882>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34883>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34881>:
        D.34884 = mini_get_debug_options ();
        D.34885 = D.34884->break_on_unverified;
        if (D.34885 != 0) goto <D.34886>; else goto unverified;
        <D.34886>:
        raise (5);
        <D.34878>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34887 = D.31048;
        D.34888 = D.34887 + 1;
        cfg->num_bblocks = D.34888;
        D.34889 = (int) D.34887;
        tblock->block_num = D.34889;
        tblock->cil_code = ip;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34890>; else goto <D.34891>;
        <D.34890>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34891>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34876>:
        D.34657 = ins->data.op[1].many_blocks;
        D.34660 = D.34657 + 8;
        *D.34660 = tblock;
        start_new_bblock = 2;
        sp = stack_start;
        inline_costs = inline_costs + 10;
        goto <D.27857>;
      }
      <D.28098>:
      <D.28099>:
      <D.28100>:
      <D.28101>:
      <D.28102>:
      <D.28103>:
      <D.28104>:
      <D.28105>:
      <D.28106>:
      <D.28107>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.34892>; else goto <D.34893>;
      <D.34892>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34894>; else goto <D.34895>;
      <D.34894>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34896>; else goto <D.34897>;
      <D.34896>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34897>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34895>:
      D.34898 = mini_get_debug_options ();
      D.34899 = D.34898->break_on_unverified;
      if (D.34899 != 0) goto <D.34900>; else goto unverified;
      <D.34900>:
      raise (5);
      <D.34893>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.34901>; else goto <D.34902>;
      <D.34901>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.34903>; else goto <D.34904>;
      <D.34903>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.34905>; else goto <D.34906>;
      <D.34905>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34906>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34904>:
      D.34907 = mini_get_debug_options ();
      D.34908 = D.34907->break_on_unverified;
      if (D.34908 != 0) goto <D.34909>; else goto unverified;
      <D.34909>:
      raise (5);
      <D.34902>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ip = ip + 1;
      D.32491 = MEM[(const guint32 *)ip];
      D.34705 = (int) D.32491;
      D.34706 = (sizetype) D.34705;
      D.34707 = D.34706 + 4;
      target = ip + D.34707;
      ip = ip + 4;
      {
        struct MonoInst * cmp;

        sp = sp + 18446744073709551600;
        D.30941 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30941, 80);
        cmp->data.op[1].const_val = 0;
        D.34910 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.34910;
        cmp->prev = 0B;
        D.34911 = cmp->prev;
        cmp->next = D.34911;
        cmp->opcode = 322;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.34912 = cmp->sreg3;
        cmp->sreg2 = D.34912;
        D.34913 = cmp->sreg2;
        cmp->sreg1 = D.34913;
        D.31162 = cfg->ip;
        cmp->cil_code = D.31162;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        cmp->sreg1 = D.32139;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        cmp->sreg2 = D.33091;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (cmp, D.31957, D.33090);
        D.34914 = cmp->type;
        if (D.34914 == 0) goto <D.34915>; else goto <D.34916>;
        <D.34915>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34917>; else goto <D.34918>;
        <D.34917>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34919>; else goto <D.34920>;
        <D.34919>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34920>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34918>:
        D.34921 = mini_get_debug_options ();
        D.34922 = D.34921->break_on_unverified;
        if (D.34922 != 0) goto <D.34923>; else goto unverified;
        <D.34923>:
        raise (5);
        <D.34916>:
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (ins, D.31957, D.33090);
        D.30941 = cfg->mempool;
        D.34924 = mono_mempool_alloc (D.30941, 16);
        ins->data.op[1].many_blocks = D.34924;
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        tblock = *D.34571;
        if (tblock == 0B) goto <D.34925>; else goto <D.34926>;
        <D.34925>:
        if (target >= end) goto <D.34927>; else goto <D.34929>;
        <D.34929>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.34927>; else goto <D.34928>;
        <D.34927>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34930>; else goto <D.34931>;
        <D.34930>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34932>; else goto <D.34933>;
        <D.34932>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34933>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34931>:
        D.34934 = mini_get_debug_options ();
        D.34935 = D.34934->break_on_unverified;
        if (D.34935 != 0) goto <D.34936>; else goto unverified;
        <D.34936>:
        raise (5);
        <D.34928>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34937 = D.31048;
        D.34938 = D.34937 + 1;
        cfg->num_bblocks = D.34938;
        D.34939 = (int) D.34937;
        tblock->block_num = D.34939;
        tblock->cil_code = target;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34940>; else goto <D.34941>;
        <D.34940>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34941>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34926>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        D.34657 = ins->data.op[1].many_blocks;
        *D.34657 = tblock;
        if (0 != 0) goto <D.34942>; else goto <D.34943>;
        <D.34942>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, 0B);
        D.34657 = ins->data.op[1].many_blocks;
        D.34660 = D.34657 + 8;
        *D.34660 = 0B;
        start_new_bblock = 1;
        goto <D.34944>;
        <D.34943>:
        D.31071 = cfg->cil_offset_to_bb;
        ip.75 = (long int) ip;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31666 = ip.75 - D.31077;
        D.31667 = (long unsigned int) D.31666;
        D.31668 = D.31667 * 8;
        D.31669 = D.31071 + D.31668;
        tblock = *D.31669;
        if (tblock == 0B) goto <D.34945>; else goto <D.34946>;
        <D.34945>:
        if (ip >= end) goto <D.34947>; else goto <D.34949>;
        <D.34949>:
        D.31088 = header->code;
        if (D.31088 > ip) goto <D.34947>; else goto <D.34948>;
        <D.34947>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34950>; else goto <D.34951>;
        <D.34950>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34952>; else goto <D.34953>;
        <D.34952>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34953>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34951>:
        D.34954 = mini_get_debug_options ();
        D.34955 = D.34954->break_on_unverified;
        if (D.34955 != 0) goto <D.34956>; else goto unverified;
        <D.34956>:
        raise (5);
        <D.34948>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.34957 = D.31048;
        D.34958 = D.34957 + 1;
        cfg->num_bblocks = D.34958;
        D.34959 = (int) D.34957;
        tblock->block_num = D.34959;
        tblock->cil_code = ip;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.34960>; else goto <D.34961>;
        <D.34960>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.34961>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.34946>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        D.34657 = ins->data.op[1].many_blocks;
        D.34660 = D.34657 + 8;
        *D.34660 = tblock;
        start_new_bblock = 2;
        <D.34944>:
        if (sp != stack_start) goto <D.34962>; else goto <D.34963>;
        <D.34962>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31732 = (int) D.31731;
        handle_stack_args (cfg, stack_start, D.31732);
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31733 = D.31336 & 35184372088832;
        if (D.31733 != 0) goto <D.34964>; else goto <D.34965>;
        <D.34964>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34966>; else goto <D.34967>;
        <D.34966>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34968>; else goto <D.34969>;
        <D.34968>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34969>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34967>:
        D.34970 = mini_get_debug_options ();
        D.34971 = D.34970->break_on_unverified;
        if (D.34971 != 0) goto <D.34972>; else goto unverified;
        <D.34972>:
        raise (5);
        <D.34965>:
        <D.34963>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34973>; else goto <D.34974>;
        <D.34973>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = cmp;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        cmp->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        goto <D.34975>;
        <D.34974>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34975>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.34976>; else goto <D.34977>;
        <D.34976>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.34978>;
        <D.34977>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.34978>:
      }
      sp = stack_start;
      inline_costs = inline_costs + 10;
      goto <D.27857>;
      <D.28109>:
      {
        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.34979 = alloc_preg (cfg);
        offset_reg = (int) D.34979;
        D.34980 = alloc_preg (cfg);
        target_reg = (int) D.34980;
        D.34981 = alloc_preg (cfg);
        table_reg = (int) D.34981;
        D.34982 = alloc_preg (cfg);
        sum_reg = (int) D.34982;
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.34983>; else goto <D.34984>;
        <D.34983>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34985>; else goto <D.34986>;
        <D.34985>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34987>; else goto <D.34988>;
        <D.34987>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34988>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34986>:
        D.34989 = mini_get_debug_options ();
        D.34990 = D.34989->break_on_unverified;
        if (D.34990 != 0) goto <D.34991>; else goto unverified;
        <D.34991>:
        raise (5);
        <D.34984>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.34992>; else goto <D.34993>;
        <D.34992>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.34994>; else goto <D.34995>;
        <D.34994>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.34996>; else goto <D.34997>;
        <D.34996>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34997>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34995>:
        D.34998 = mini_get_debug_options ();
        D.34999 = D.34998->break_on_unverified;
        if (D.34999 != 0) goto <D.35000>; else goto unverified;
        <D.35000>:
        raise (5);
        <D.34993>:
        D.32400 = ip + 1;
        D.32401 = *D.32400;
        n = (int) D.32401;
        sp = sp + 18446744073709551608;
        src1 = *sp;
        D.35001 = src1->type;
        if (D.35001 != 1) goto <D.35002>; else goto <D.35003>;
        <D.35002>:
        D.35001 = src1->type;
        if (D.35001 != 3) goto <D.35004>; else goto <D.35005>;
        <D.35004>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35006>; else goto <D.35007>;
        <D.35006>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35008>; else goto <D.35009>;
        <D.35008>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35009>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35007>:
        D.35010 = mini_get_debug_options ();
        D.35011 = D.35010->break_on_unverified;
        if (D.35011 != 0) goto <D.35012>; else goto unverified;
        <D.35012>:
        raise (5);
        <D.35005>:
        <D.35003>:
        ip = ip + 5;
        D.31883 = (long unsigned int) n;
        D.35013 = D.31883 * 4;
        D.35014 = ip + D.35013;
        if (D.35014 > end) goto <D.35015>; else goto <D.35016>;
        <D.35015>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35017>; else goto <D.35018>;
        <D.35017>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35019>; else goto <D.35020>;
        <D.35019>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35020>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35018>:
        D.35021 = mini_get_debug_options ();
        D.35022 = D.35021->break_on_unverified;
        if (D.35022 != 0) goto <D.35023>; else goto unverified;
        <D.35023>:
        raise (5);
        <D.35016>:
        D.31883 = (long unsigned int) n;
        D.35013 = D.31883 * 4;
        target = ip + D.35013;
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        default_bblock = *D.34571;
        if (default_bblock == 0B) goto <D.35024>; else goto <D.35025>;
        <D.35024>:
        if (target >= end) goto <D.35026>; else goto <D.35028>;
        <D.35028>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.35026>; else goto <D.35027>;
        <D.35026>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35029>; else goto <D.35030>;
        <D.35029>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35031>; else goto <D.35032>;
        <D.35031>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35032>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35030>:
        D.35033 = mini_get_debug_options ();
        D.35034 = D.35033->break_on_unverified;
        if (D.35034 != 0) goto <D.35035>; else goto unverified;
        <D.35035>:
        raise (5);
        <D.35027>:
        D.30941 = cfg->mempool;
        default_bblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.35036 = D.31048;
        D.35037 = D.35036 + 1;
        cfg->num_bblocks = D.35037;
        D.35038 = (int) D.35036;
        default_bblock->block_num = D.35038;
        default_bblock->cil_code = target;
        D.35039 = default_bblock->cil_code;
        if (D.35039 != 0B) goto <D.35040>; else goto <D.35041>;
        <D.35040>:
        D.31071 = cfg->cil_offset_to_bb;
        D.35039 = default_bblock->cil_code;
        D.35042 = (long int) D.35039;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.35043 = D.35042 - D.31077;
        D.35044 = (long unsigned int) D.35043;
        D.35045 = D.35044 * 8;
        D.35046 = D.31071 + D.35045;
        *D.35046 = default_bblock;
        <D.35041>:
        D.31108 = cfg->real_offset;
        default_bblock->real_offset = D.31108;
        <D.35025>:
        D.35047 = default_bblock->flags;
        D.35048 = D.35047 | 32;
        default_bblock->flags = D.35048;
        D.30941 = cfg->mempool;
        D.31883 = (long unsigned int) n;
        D.35049 = (unsigned int) D.31883;
        D.35050 = D.35049 * 8;
        targets = mono_mempool_alloc (D.30941, D.35050);
        i = 0;
        goto <D.28120>;
        <D.28119>:
        D.31071 = cfg->cil_offset_to_bb;
        D.32491 = MEM[(const guint32 *)ip];
        D.34705 = (int) D.32491;
        D.34706 = (sizetype) D.34705;
        D.35051 = target + D.34706;
        D.35052 = (long int) D.35051;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.35053 = D.35052 - D.31077;
        D.35054 = (long unsigned int) D.35053;
        D.35055 = D.35054 * 8;
        D.35056 = D.31071 + D.35055;
        tblock = *D.35056;
        if (tblock == 0B) goto <D.35057>; else goto <D.35058>;
        <D.35057>:
        D.32491 = MEM[(const guint32 *)ip];
        D.34705 = (int) D.32491;
        D.34706 = (sizetype) D.34705;
        D.35051 = target + D.34706;
        if (D.35051 >= end) goto <D.35059>; else goto <D.35061>;
        <D.35061>:
        D.32491 = MEM[(const guint32 *)ip];
        D.34705 = (int) D.32491;
        D.34706 = (sizetype) D.34705;
        D.35062 = target + D.34706;
        D.31088 = header->code;
        if (D.35062 < D.31088) goto <D.35059>; else goto <D.35060>;
        <D.35059>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35063>; else goto <D.35064>;
        <D.35063>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35065>; else goto <D.35066>;
        <D.35065>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35066>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35064>:
        D.35067 = mini_get_debug_options ();
        D.35068 = D.35067->break_on_unverified;
        if (D.35068 != 0) goto <D.35069>; else goto unverified;
        <D.35069>:
        raise (5);
        <D.35060>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.35070 = D.31048;
        D.35071 = D.35070 + 1;
        cfg->num_bblocks = D.35071;
        D.35072 = (int) D.35070;
        tblock->block_num = D.35072;
        D.32491 = MEM[(const guint32 *)ip];
        D.34705 = (int) D.32491;
        D.34706 = (sizetype) D.34705;
        D.35051 = target + D.34706;
        tblock->cil_code = D.35051;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.35073>; else goto <D.35074>;
        <D.35073>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.35074>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.35058>:
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.35075 = targets + D.31690;
        *D.35075 = tblock;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.35075 = targets + D.31690;
        D.35076 = *D.35075;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.35075 = targets + D.31690;
        D.35076 = *D.35075;
        D.35077 = D.35076->flags;
        D.35078 = D.35077 | 32;
        D.35076->flags = D.35078;
        ip = ip + 4;
        i = i + 1;
        <D.28120>:
        if (i < n) goto <D.28119>; else goto <D.28121>;
        <D.28121>:
        if (sp != stack_start) goto <D.35079>; else goto <D.35080>;
        <D.35079>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, default_bblock);
        i = 0;
        goto <D.28123>;
        <D.28122>:
        bblock.70 = bblock;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.35075 = targets + D.31690;
        D.35076 = *D.35075;
        link_bblock (cfg, bblock.70, D.35076);
        i = i + 1;
        <D.28123>:
        if (i < n) goto <D.28122>; else goto <D.28124>;
        <D.28124>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31732 = (int) D.31731;
        handle_stack_args (cfg, stack_start, D.31732);
        sp = stack_start;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31733 = D.31336 & 35184372088832;
        if (D.31733 != 0) goto <D.35081>; else goto <D.35082>;
        <D.35081>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35083>; else goto <D.35084>;
        <D.35083>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35085>; else goto <D.35086>;
        <D.35085>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35086>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35084>:
        D.35087 = mini_get_debug_options ();
        D.35088 = D.35087->break_on_unverified;
        if (D.35088 != 0) goto <D.35089>; else goto unverified;
        <D.35089>:
        raise (5);
        <D.35082>:
        <D.35080>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35090 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35090;
          inst->prev = 0B;
          D.35091 = inst->prev;
          inst->next = D.35091;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35092 = inst->sreg3;
          inst->sreg2 = D.35092;
          D.35093 = inst->sreg2;
          inst->sreg1 = D.35093;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          D.35094 = src1->dreg;
          inst->sreg1 = D.35094;
          D.32978 = (long int) n;
          inst->data.op[1].const_val = D.32978;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35095>; else goto <D.35096>;
          <D.35095>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35097>;
          <D.35096>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35097>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.35098 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.35098;
          ins->prev = 0B;
          D.35099 = ins->prev;
          ins->next = D.35099;
          ins->opcode = 654;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.35100 = ins->sreg3;
          ins->sreg2 = D.35100;
          D.35101 = ins->sreg2;
          ins->sreg1 = D.35101;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          if (0 != 0) goto <D.35102>; else goto <D.35103>;
          <D.35102>:
          D.30941 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.30941, 296);
          D.31048 = cfg->num_bblocks;
          D.35104 = D.31048;
          D.35105 = D.35104 + 1;
          cfg->num_bblocks = D.35105;
          D.35106 = (int) D.35104;
          falsebb->block_num = D.35106;
          ins->data.op[0].target_block = default_bblock;
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, default_bblock);
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35107>; else goto <D.35108>;
          <D.35107>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.35109>;
          <D.35108>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35109>:
          D.35110 = falsebb->cil_code;
          if (D.35110 != 0B) goto <D.35111>; else goto <D.35112>;
          <D.35111>:
          D.31071 = cfg->cil_offset_to_bb;
          D.35110 = falsebb->cil_code;
          D.35113 = (long int) D.35110;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.35114 = D.35113 - D.31077;
          D.35115 = (long unsigned int) D.35114;
          D.35116 = D.35115 * 8;
          D.35117 = D.31071 + D.35116;
          *D.35117 = falsebb;
          <D.35112>:
          D.31108 = cfg->real_offset;
          falsebb->real_offset = D.31108;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35121>; else goto <D.35118>;
          <D.35121>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35123 = D.35122 + 64985;
          if (D.35123 <= 9) goto <D.35119>; else goto <D.35124>;
          <D.35124>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35125 = D.35122 + 64878;
          if (D.35125 <= 9) goto <D.35119>; else goto <D.35126>;
          <D.35126>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35127 = D.35122 + 64888;
          if (D.35127 <= 9) goto <D.35119>; else goto <D.35118>;
          <D.35119>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35128 = D.31191->data.op[1].many_blocks;
          D.35129 = D.35128 + 8;
          D.35130 = *D.35129;
          if (D.35130 == 0B) goto <D.35131>; else goto <D.35118>;
          <D.35131>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35128 = D.31191->data.op[1].many_blocks;
          D.35129 = D.35128 + 8;
          *D.35129 = falsebb;
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, falsebb);
          goto <D.35120>;
          <D.35118>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 == 0B) goto <D.35132>; else goto <D.35134>;
          <D.35134>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          if (D.35122 != 442) goto <D.35135>; else goto <D.35133>;
          <D.35135>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          if (D.35122 != 759) goto <D.35136>; else goto <D.35133>;
          <D.35136>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35123 = D.35122 + 64985;
          if (D.35123 > 9) goto <D.35137>; else goto <D.35133>;
          <D.35137>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35125 = D.35122 + 64878;
          if (D.35125 > 9) goto <D.35138>; else goto <D.35133>;
          <D.35138>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35127 = D.35122 + 64888;
          if (D.35127 > 9) goto <D.35132>; else goto <D.35133>;
          <D.35132>:
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, falsebb);
          <D.35133>:
          <D.35120>:
          bblock.113 = cfg->cbb;
          bblock.113->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.35139>;
          <D.35103>:
          D.30941 = cfg->mempool;
          D.35140 = mono_mempool_alloc (D.30941, 16);
          ins->data.op[1].many_blocks = D.35140;
          D.35141 = ins->data.op[1].many_blocks;
          *D.35141 = default_bblock;
          D.35141 = ins->data.op[1].many_blocks;
          D.35142 = D.35141 + 8;
          *D.35142 = 0B;
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, default_bblock);
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35143>; else goto <D.35144>;
          <D.35143>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.35145>;
          <D.35144>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35145>:
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.35146 = D.31336 & 34359738368;
          if (D.35146 == 0) goto <D.35147>; else goto <D.35148>;
          <D.35147>:
          D.30941 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.30941, 296);
          D.31048 = cfg->num_bblocks;
          D.35149 = D.31048;
          D.35150 = D.35149 + 1;
          cfg->num_bblocks = D.35150;
          D.35151 = (int) D.35149;
          falsebb->block_num = D.35151;
          D.35141 = ins->data.op[1].many_blocks;
          D.35142 = D.35141 + 8;
          *D.35142 = falsebb;
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, falsebb);
          D.35110 = falsebb->cil_code;
          if (D.35110 != 0B) goto <D.35152>; else goto <D.35153>;
          <D.35152>:
          D.31071 = cfg->cil_offset_to_bb;
          D.35110 = falsebb->cil_code;
          D.35113 = (long int) D.35110;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.35114 = D.35113 - D.31077;
          D.35115 = (long unsigned int) D.35114;
          D.35116 = D.35115 * 8;
          D.35117 = D.31071 + D.35116;
          *D.35117 = falsebb;
          <D.35153>:
          D.31108 = cfg->real_offset;
          falsebb->real_offset = D.31108;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35157>; else goto <D.35154>;
          <D.35157>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35123 = D.35122 + 64985;
          if (D.35123 <= 9) goto <D.35155>; else goto <D.35158>;
          <D.35158>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35125 = D.35122 + 64878;
          if (D.35125 <= 9) goto <D.35155>; else goto <D.35159>;
          <D.35159>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35127 = D.35122 + 64888;
          if (D.35127 <= 9) goto <D.35155>; else goto <D.35154>;
          <D.35155>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35128 = D.31191->data.op[1].many_blocks;
          D.35129 = D.35128 + 8;
          D.35130 = *D.35129;
          if (D.35130 == 0B) goto <D.35160>; else goto <D.35154>;
          <D.35160>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35128 = D.31191->data.op[1].many_blocks;
          D.35129 = D.35128 + 8;
          *D.35129 = falsebb;
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, falsebb);
          goto <D.35156>;
          <D.35154>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 == 0B) goto <D.35161>; else goto <D.35163>;
          <D.35163>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          if (D.35122 != 442) goto <D.35164>; else goto <D.35162>;
          <D.35164>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          if (D.35122 != 759) goto <D.35165>; else goto <D.35162>;
          <D.35165>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35123 = D.35122 + 64985;
          if (D.35123 > 9) goto <D.35166>; else goto <D.35162>;
          <D.35166>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35125 = D.35122 + 64878;
          if (D.35125 > 9) goto <D.35167>; else goto <D.35162>;
          <D.35167>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.35122 = D.31191->opcode;
          D.35127 = D.35122 + 64888;
          if (D.35127 > 9) goto <D.35161>; else goto <D.35162>;
          <D.35161>:
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, falsebb);
          <D.35162>:
          <D.35156>:
          bblock.113 = cfg->cbb;
          bblock.113->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.35168>;
          <D.35148>:
          bblock.113 = cfg->cbb;
          bblock.113->extended = 1;
          <D.35168>:
          <D.35139>:
        }
        bblock.113 = cfg->cbb;
        bblock = bblock.113;
        i = 0;
        goto <D.28129>;
        <D.28128>:
        bblock.70 = bblock;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.35075 = targets + D.31690;
        D.35076 = *D.35075;
        link_bblock (cfg, bblock.70, D.35076);
        i = i + 1;
        <D.28129>:
        if (i < n) goto <D.28128>; else goto <D.28130>;
        <D.28130>:
        D.30941 = cfg->mempool;
        table = mono_mempool_alloc (D.30941, 16);
        table->table = targets;
        table->table_size = n;
        use_op_switch = 0;
        if (0 != 0) goto <D.35169>; else goto <D.35170>;
        <D.35169>:
        use_op_switch = 1;
        <D.35170>:
        bblock.113 = cfg->cbb;
        bblock.113->has_jump_table = 1;
        if (use_op_switch != 0) goto <D.35171>; else goto <D.35172>;
        <D.35171>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 370;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.35094 = src1->dreg;
        ins->sreg1 = D.35094;
        ins->data.op[0].p = table;
        ins->data.op[1].many_blocks = targets;
        D.31883 = (long unsigned int) n;
        D.35173 = (struct MonoClass *) D.31883;
        ins->klass = D.35173;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35174>; else goto <D.35175>;
        <D.35174>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.35176>;
        <D.35175>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35176>:
        goto <D.35177>;
        <D.35172>:
        if (1 != 0) goto <D.35178>; else goto <D.35179>;
        <D.35178>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35180 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35180;
          inst->prev = 0B;
          D.35181 = inst->prev;
          inst->next = D.35181;
          inst->opcode = 439;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35182 = inst->sreg3;
          inst->sreg2 = D.35182;
          D.35183 = inst->sreg2;
          inst->sreg1 = D.35183;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = offset_reg;
          D.35094 = src1->dreg;
          inst->sreg1 = D.35094;
          inst->data.op[1].const_val = 3;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35184>; else goto <D.35185>;
          <D.35184>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35186>;
          <D.35185>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35186>:
        }
        goto <D.35187>;
        <D.35179>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35188 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35188;
          inst->prev = 0B;
          D.35189 = inst->prev;
          inst->next = D.35189;
          inst->opcode = 439;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35190 = inst->sreg3;
          inst->sreg2 = D.35190;
          D.35191 = inst->sreg2;
          inst->sreg1 = D.35191;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = offset_reg;
          D.35094 = src1->dreg;
          inst->sreg1 = D.35094;
          inst->data.op[1].const_val = 2;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35192>; else goto <D.35193>;
          <D.35192>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35194>;
          <D.35193>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35194>:
        }
        <D.35187>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35195 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35195;
          inst->prev = 0B;
          D.35196 = inst->prev;
          inst->next = D.35196;
          inst->opcode = 765;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35197 = inst->sreg3;
          inst->sreg2 = D.35197;
          D.35198 = inst->sreg2;
          inst->sreg1 = D.35198;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35199>; else goto <D.35200>;
          <D.35199>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35201>;
          <D.35200>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35201>:
        }
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.35202>; else goto <D.35203>;
        <D.35202>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35204 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35204;
          inst->prev = 0B;
          D.35205 = inst->prev;
          inst->next = D.35205;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.35207>; else goto <D.35208>;
          <D.35207>:
          iftmp.141 = 734;
          goto <D.35209>;
          <D.35208>:
          iftmp.141 = 363;
          <D.35209>:
          inst->opcode = iftmp.141;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35210 = inst->sreg3;
          inst->sreg2 = D.35210;
          D.35211 = inst->sreg2;
          inst->sreg1 = D.35211;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.35212>; else goto <D.35213>;
          <D.35212>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.30941 = cfg->mempool;
            group = mono_mempool_alloc (D.30941, 80);
            group->data.op[1].const_val = 0;
            D.35214 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.35214;
            group->prev = 0B;
            D.35215 = group->prev;
            group->next = D.35215;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.35216 = group->sreg3;
            group->sreg2 = D.35216;
            D.35217 = group->sreg2;
            group->sreg1 = D.35217;
            D.31162 = cfg->ip;
            group->cil_code = D.31162;
            group->data.op[0].src = table;
            group->data.op[1].src = 8B;
            D.35218 = got_loc->dreg;
            inst->sreg1 = D.35218;
            inst->data.op[1].p = group;
          }
          goto <D.35219>;
          <D.35213>:
          inst->data.op[0].p = table;
          inst->data.op[1].src = 8B;
          <D.35219>:
          inst->type = 3;
          D.35220 = alloc_dreg (cfg, 3);
          D.35221 = (int) D.35220;
          inst->dreg = D.35221;
          inst->dreg = table_reg;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35222>; else goto <D.35223>;
          <D.35222>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35224>;
          <D.35223>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35224>:
        }
        goto <D.35225>;
        <D.35203>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 731;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->data.op[1].const_val = 8;
        ins->data.op[0].p = table;
        ins->dreg = table_reg;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35226>; else goto <D.35227>;
        <D.35226>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.35228>;
        <D.35227>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35228>:
        <D.35225>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35229 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35229;
          inst->prev = 0B;
          D.35230 = inst->prev;
          inst->next = D.35230;
          inst->opcode = 479;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35231 = inst->sreg3;
          inst->sreg2 = D.35231;
          D.35232 = inst->sreg2;
          inst->sreg1 = D.35232;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = sum_reg;
          inst->sreg1 = table_reg;
          inst->sreg2 = offset_reg;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35233>; else goto <D.35234>;
          <D.35233>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35235>;
          <D.35234>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35235>:
        }
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35236 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35236;
          inst->prev = 0B;
          D.35237 = inst->prev;
          inst->next = D.35237;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35238 = inst->sreg3;
          inst->sreg2 = D.35238;
          D.35239 = inst->sreg2;
          inst->sreg1 = D.35239;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = target_reg;
          inst->sreg1 = sum_reg;
          inst->data.op[0].const_val = 0;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35240>; else goto <D.35241>;
          <D.35240>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35242>;
          <D.35241>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35242>:
        }
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.35243 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.35243;
          inst->prev = 0B;
          D.35244 = inst->prev;
          inst->next = D.35244;
          inst->opcode = 759;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.35245 = inst->sreg3;
          inst->sreg2 = D.35245;
          D.35246 = inst->sreg2;
          inst->sreg1 = D.35246;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          inst->sreg1 = target_reg;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.35247>; else goto <D.35248>;
          <D.35247>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.35249>;
          <D.35248>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.35249>:
        }
        <D.35177>:
        start_new_bblock = 1;
        inline_costs = inline_costs + 20;
        goto <D.27857>;
      }
      <D.28140>:
      <D.28141>:
      <D.28142>:
      <D.28143>:
      <D.28144>:
      <D.28145>:
      <D.28146>:
      <D.28147>:
      <D.28148>:
      <D.28149>:
      <D.28150>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.35250>; else goto <D.35251>;
      <D.35250>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35252>; else goto <D.35253>;
      <D.35252>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35254>; else goto <D.35255>;
      <D.35254>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35255>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35253>:
      D.35256 = mini_get_debug_options ();
      D.35257 = D.35256->break_on_unverified;
      if (D.35257 != 0) goto <D.35258>; else goto unverified;
      <D.35258>:
      raise (5);
      <D.35251>:
      sp = sp + 18446744073709551608;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      switch (D.31839) <default: <D.28156>, case 76: <D.28154>, case 78: <D.28151>, case 79: <D.28152>, case 80: <D.28155>>
      <D.28151>:
      <D.28152>:
      D.35259 = alloc_freg (cfg);
      dreg = (int) D.35259;
      goto <D.28153>;
      <D.28154>:
      D.35260 = alloc_lreg (cfg);
      dreg = (int) D.35260;
      goto <D.28153>;
      <D.28155>:
      D.35261 = alloc_ireg_ref (cfg);
      dreg = (int) D.35261;
      goto <D.28153>;
      <D.28156>:
      D.35262 = alloc_preg (cfg);
      dreg = (int) D.35262;
      <D.28153>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      D.35263 = ldind_to_load_membase (D.31839);
      D.35264 = (short unsigned int) D.35263;
      ins->opcode = D.35264;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->dreg = dreg;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      D.35265 = D.31839 + -70;
      D.35266 = ldind_type[D.35265];
      ins->type = D.35266;
      D.31805 = ins->flags;
      D.35267 = (unsigned char) ins_flag;
      D.35268 = D.31805 | D.35267;
      ins->flags = D.35268;
      ins_flag = 0;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.35269>; else goto <D.35270>;
      <D.35269>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.35271>;
      <D.35270>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.35271>:
      sp.142 = sp;
      sp = sp.142 + 8;
      *sp.142 = ins;
      D.31805 = ins->flags;
      D.35273 = (int) D.31805;
      D.35274 = D.35273 & 4;
      if (D.35274 != 0) goto <D.35275>; else goto <D.35276>;
      <D.35275>:
      emit_memory_barrier (cfg, 4);
      <D.35276>:
      ip = ip + 1;
      goto <D.27857>;
      <D.28157>:
      <D.28158>:
      <D.28159>:
      <D.28160>:
      <D.28161>:
      <D.28162>:
      <D.28163>:
      <D.28164>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.35277>; else goto <D.35278>;
      <D.35277>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35279>; else goto <D.35280>;
      <D.35279>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35281>; else goto <D.35282>;
      <D.35281>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35282>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35280>:
      D.35283 = mini_get_debug_options ();
      D.35284 = D.35283->break_on_unverified;
      if (D.35284 != 0) goto <D.35285>; else goto unverified;
      <D.35285>:
      raise (5);
      <D.35278>:
      sp = sp + 18446744073709551600;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      D.35286 = stind_to_store_membase (D.31839);
      D.35287 = (short unsigned int) D.35286;
      ins->opcode = D.35287;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.33091 = D.33090->dreg;
      ins->sreg1 = D.33091;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->dreg = D.32139;
      ins->data.op[0].const_val = 0;
      D.31805 = ins->flags;
      D.35267 = (unsigned char) ins_flag;
      D.35268 = D.31805 | D.35267;
      ins->flags = D.35268;
      ins_flag = 0;
      D.31805 = ins->flags;
      D.35273 = (int) D.31805;
      D.35274 = D.35273 & 4;
      if (D.35274 != 0) goto <D.35288>; else goto <D.35289>;
      <D.35288>:
      emit_memory_barrier (cfg, 4);
      <D.35289>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.35290>; else goto <D.35291>;
      <D.35290>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.35292>;
      <D.35291>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.35292>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.34146 = D.31336 & 1152921504606846976;
      if (D.34146 != 0) goto <D.35295>; else goto <D.35296>;
      <D.35295>:
      D.31838 = *ip;
      if (D.31838 == 81) goto <D.35297>; else goto <D.35298>;
      <D.35297>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 != 96) goto <D.35299>; else goto <D.35300>;
      <D.35299>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35301 = D.33090->opcode;
      if (D.35301 != 363) goto <D.35293>; else goto <D.35302>;
      <D.35302>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35303 = D.33090->data.op[0].p;
      if (D.35303 != 0B) goto <D.35293>; else goto <D.35294>;
      <D.35293>:
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      emit_write_barrier (cfg, D.31957, D.33090);
      <D.35294>:
      <D.35300>:
      <D.35298>:
      <D.35296>:
      inline_costs = inline_costs + 1;
      ip = ip + 1;
      goto <D.27857>;
      <D.28165>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.35304>; else goto <D.35305>;
      <D.35304>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35306>; else goto <D.35307>;
      <D.35306>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35308>; else goto <D.35309>;
      <D.35308>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35309>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35307>:
      D.35310 = mini_get_debug_options ();
      D.35311 = D.35310->break_on_unverified;
      if (D.35311 != 0) goto <D.35312>; else goto unverified;
      <D.35312>:
      raise (5);
      <D.35305>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551600;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.33091 = D.33090->dreg;
      ins->sreg2 = D.33091;
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      type_from_op (ins, D.31957, D.33090);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35313>; else goto <D.35314>;
      <D.35313>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35315>; else goto <D.35316>;
      <D.35315>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35317>; else goto <D.35318>;
      <D.35317>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35318>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35316>:
      D.35319 = mini_get_debug_options ();
      D.35320 = D.35319->break_on_unverified;
      if (D.35320 != 0) goto <D.35321>; else goto unverified;
      <D.35321>:
      raise (5);
      <D.35314>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35322 = alloc_dreg (cfg, D.31706);
      D.35323 = (int) D.35322;
      ins->dreg = D.35323;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35301 = D.33090->opcode;
      if (D.35301 == 362) goto <D.35324>; else goto <D.35325>;
      <D.35324>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35326 = D.33090->data.op[0].const_val;
      D.35327 = mono_arch_is_inst_imm (D.35326);
      if (D.35327 != 0) goto <D.35328>; else goto <D.35329>;
      <D.35328>:
      {
        int imm_opcode;

        D.31709 = ins->opcode;
        D.35330 = (int) D.31709;
        imm_opcode = mono_op_to_op_imm_noemul (D.35330);
        if (imm_opcode != -1) goto <D.35331>; else goto <D.35332>;
        <D.35331>:
        D.35333 = (short unsigned int) imm_opcode;
        ins->opcode = D.35333;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35326 = D.33090->data.op[0].const_val;
        D.35334 = (void *) D.35326;
        ins->data.op[1].p = D.35334;
        ins->sreg2 = -1;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33090->opcode = 316;
        <D.35332>:
      }
      <D.35329>:
      <D.35325>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35335>; else goto <D.35336>;
      <D.35335>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35337>;
      <D.35336>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35337>:
      sp.143 = sp;
      sp = sp.143 + 8;
      D.35339 = mono_decompose_opcode (cfg, ins);
      *sp.143 = D.35339;
      ip = ip + 1;
      goto <D.27857>;
      <D.28167>:
      <D.28168>:
      <D.28169>:
      <D.28170>:
      <D.28171>:
      <D.28172>:
      <D.28173>:
      <D.28174>:
      <D.28175>:
      <D.28176>:
      <D.28177>:
      <D.28178>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.35340>; else goto <D.35341>;
      <D.35340>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35342>; else goto <D.35343>;
      <D.35342>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35344>; else goto <D.35345>;
      <D.35344>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35345>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35343>:
      D.35346 = mini_get_debug_options ();
      D.35347 = D.35346->break_on_unverified;
      if (D.35347 != 0) goto <D.35348>; else goto unverified;
      <D.35348>:
      raise (5);
      <D.35341>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551600;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.33091 = D.33090->dreg;
      ins->sreg2 = D.33091;
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      type_from_op (ins, D.31957, D.33090);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35349>; else goto <D.35350>;
      <D.35349>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35351>; else goto <D.35352>;
      <D.35351>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35353>; else goto <D.35354>;
      <D.35353>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35354>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35352>:
      D.35355 = mini_get_debug_options ();
      D.35356 = D.35355->break_on_unverified;
      if (D.35356 != 0) goto <D.35357>; else goto unverified;
      <D.35357>:
      raise (5);
      <D.35350>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 == 3) goto <D.35358>; else goto <D.35359>;
      <D.35358>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35360 = D.33090->type;
      if (D.35360 == 1) goto <D.35361>; else goto <D.35362>;
      <D.35361>:
      {
        struct MonoInst * widen;
        int dr;

        D.35363 = alloc_preg (cfg);
        dr = (int) D.35363;
        D.30941 = cfg->mempool;
        widen = mono_mempool_alloc (D.30941, 80);
        widen->data.op[1].const_val = 0;
        D.35364 = widen->data.op[1].const_val;
        widen->data.op[0].const_val = D.35364;
        widen->prev = 0B;
        D.35365 = widen->prev;
        widen->next = D.35365;
        widen->opcode = 762;
        widen->flags = 0;
        widen->type = 0;
        widen->dreg = -1;
        widen->sreg3 = -1;
        D.35366 = widen->sreg3;
        widen->sreg2 = D.35366;
        D.35367 = widen->sreg2;
        widen->sreg1 = D.35367;
        D.31162 = cfg->ip;
        widen->cil_code = D.31162;
        widen->dreg = dr;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        widen->sreg1 = D.33091;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35368>; else goto <D.35369>;
        <D.35368>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = widen;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        widen->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = widen;
        goto <D.35370>;
        <D.35369>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = widen;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35370>:
        D.35371 = widen->dreg;
        ins->sreg2 = D.35371;
      }
      <D.35362>:
      <D.35359>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35372 = alloc_dreg (cfg, D.31706);
      D.35373 = (int) D.35372;
      ins->dreg = D.35373;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35301 = D.33090->opcode;
      D.35374 = D.35301 + 65174;
      if (D.35374 <= 1) goto <D.35375>; else goto <D.35376>;
      <D.35375>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35301 = D.33090->opcode;
      if (D.35301 == 362) goto <D.35378>; else goto <D.35379>;
      <D.35378>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      iftmp.144 = D.33090->data.op[0].const_val;
      goto <D.35380>;
      <D.35379>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      iftmp.144 = D.33090->data.i8const;
      <D.35380>:
      D.35381 = mono_arch_is_inst_imm (iftmp.144);
      if (D.35381 != 0) goto <D.35382>; else goto <D.35383>;
      <D.35382>:
      {
        int imm_opcode;

        D.31709 = ins->opcode;
        D.35330 = (int) D.31709;
        imm_opcode = mono_op_to_op_imm_noemul (D.35330);
        if (imm_opcode != -1) goto <D.35384>; else goto <D.35385>;
        <D.35384>:
        D.35386 = (short unsigned int) imm_opcode;
        ins->opcode = D.35386;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35301 = D.33090->opcode;
        if (D.35301 == 363) goto <D.35387>; else goto <D.35388>;
        <D.35387>:
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35389 = D.33090->data.i8const;
        ins->data.op[1].const_val = D.35389;
        goto <D.35390>;
        <D.35388>:
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35326 = D.33090->data.op[0].const_val;
        ins->data.op[1].const_val = D.35326;
        <D.35390>:
        ins->sreg2 = -1;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35391 = D.33090->next;
        if (D.35391 == 0B) goto <D.35392>; else goto <D.35393>;
        <D.35392>:
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33090->opcode = 316;
        <D.35393>:
        <D.35385>:
      }
      <D.35383>:
      <D.35376>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35394>; else goto <D.35395>;
      <D.35394>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35396>;
      <D.35395>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35396>:
      sp.145 = sp;
      sp = sp.145 + 8;
      D.35398 = mono_decompose_opcode (cfg, ins);
      *sp.145 = D.35398;
      ip = ip + 1;
      goto <D.27857>;
      <D.28182>:
      <D.28183>:
      <D.28184>:
      <D.28185>:
      <D.28186>:
      <D.28187>:
      <D.28188>:
      <D.28189>:
      <D.28190>:
      <D.28191>:
      <D.28192>:
      <D.28193>:
      <D.28194>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.35399>; else goto <D.35400>;
      <D.35399>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35401>; else goto <D.35402>;
      <D.35401>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35403>; else goto <D.35404>;
      <D.35403>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35404>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35402>:
      D.35405 = mini_get_debug_options ();
      D.35406 = D.35405->break_on_unverified;
      if (D.35406 != 0) goto <D.35407>; else goto unverified;
      <D.35407>:
      raise (5);
      <D.35400>:
      D.31838 = *ip;
      if (D.31838 == 106) goto <D.35408>; else goto <D.35411>;
      <D.35411>:
      D.31838 = *ip;
      if (D.31838 == 110) goto <D.35408>; else goto <D.35409>;
      <D.35408>:
      D.34772 = sp + 18446744073709551608;
      D.34773 = *D.34772;
      D.35412 = D.34773->opcode;
      if (D.35412 == 362) goto <D.35413>; else goto <D.35409>;
      <D.35413>:
      {
        int data;

        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.35414 = D.34773->data.op[0].const_val;
        data = (int) D.35414;
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.34773->opcode = 363;
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.34773->type = 2;
        D.31838 = *ip;
        if (D.31838 == 110) goto <D.35415>; else goto <D.35416>;
        <D.35415>:
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        data.146 = (unsigned int) data;
        D.35418 = (long int) data.146;
        D.34773->data.op[0].const_val = D.35418;
        goto <D.35419>;
        <D.35416>:
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.35420 = (long int) data;
        D.34773->data.op[0].const_val = D.35420;
        <D.35419>:
        D.34772 = sp + 18446744073709551608;
        D.34773 = *D.34772;
        D.35421 = alloc_dreg (cfg, 2);
        D.35422 = (int) D.35421;
        D.34773->dreg = D.35422;
      }
      goto <D.35410>;
      <D.35409>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35423>; else goto <D.35424>;
      <D.35423>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35425>; else goto <D.35426>;
      <D.35425>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35427>; else goto <D.35428>;
      <D.35427>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35428>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35426>:
      D.35429 = mini_get_debug_options ();
      D.35430 = D.35429->break_on_unverified;
      if (D.35430 != 0) goto <D.35431>; else goto unverified;
      <D.35431>:
      raise (5);
      <D.35424>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35432 = alloc_dreg (cfg, D.31706);
      D.35433 = (int) D.35432;
      ins->dreg = D.35433;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35434>; else goto <D.35435>;
      <D.35434>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35436>;
      <D.35435>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35436>:
      sp.147 = sp;
      sp = sp.147 + 8;
      D.35438 = mono_decompose_opcode (cfg, ins);
      *sp.147 = D.35438;
      <D.35410>:
      ip = ip + 1;
      goto <D.27857>;
      <D.28196>:
      <D.28197>:
      <D.28198>:
      <D.28199>:
      <D.28200>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.35439>; else goto <D.35440>;
      <D.35439>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35441>; else goto <D.35442>;
      <D.35441>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35443>; else goto <D.35444>;
      <D.35443>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35444>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35442>:
      D.35445 = mini_get_debug_options ();
      D.35446 = D.35445->break_on_unverified;
      if (D.35446 != 0) goto <D.35447>; else goto unverified;
      <D.35447>:
      raise (5);
      <D.35440>:
      D.34772 = sp + 18446744073709551608;
      D.34773 = *D.34772;
      D.34774 = D.34773->type;
      if (D.34774 == 4) goto <D.35448>; else goto <D.35449>;
      <D.35448>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 185;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35450>; else goto <D.35451>;
      <D.35450>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35452>; else goto <D.35453>;
      <D.35452>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35454>; else goto <D.35455>;
      <D.35454>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35455>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35453>:
      D.35456 = mini_get_debug_options ();
      D.35457 = D.35456->break_on_unverified;
      if (D.35457 != 0) goto <D.35458>; else goto unverified;
      <D.35458>:
      raise (5);
      <D.35451>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35459 = alloc_dreg (cfg, D.31706);
      D.35460 = (int) D.35459;
      ins->dreg = D.35460;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35461>; else goto <D.35462>;
      <D.35461>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35463>;
      <D.35462>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35463>:
      sp.148 = sp;
      sp = sp.148 + 8;
      D.35465 = mono_decompose_opcode (cfg, ins);
      *sp.148 = D.35465;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35466>; else goto <D.35467>;
      <D.35466>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35468>; else goto <D.35469>;
      <D.35468>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35470>; else goto <D.35471>;
      <D.35470>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35471>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35469>:
      D.35472 = mini_get_debug_options ();
      D.35473 = D.35472->break_on_unverified;
      if (D.35473 != 0) goto <D.35474>; else goto unverified;
      <D.35474>:
      raise (5);
      <D.35467>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35475 = alloc_dreg (cfg, D.31706);
      D.35476 = (int) D.35475;
      ins->dreg = D.35476;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35477>; else goto <D.35478>;
      <D.35477>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35479>;
      <D.35478>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35479>:
      sp.149 = sp;
      sp = sp.149 + 8;
      D.35481 = mono_decompose_opcode (cfg, ins);
      *sp.149 = D.35481;
      goto <D.35482>;
      <D.35449>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35483>; else goto <D.35484>;
      <D.35483>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35485>; else goto <D.35486>;
      <D.35485>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35487>; else goto <D.35488>;
      <D.35487>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35488>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35486>:
      D.35489 = mini_get_debug_options ();
      D.35490 = D.35489->break_on_unverified;
      if (D.35490 != 0) goto <D.35491>; else goto unverified;
      <D.35491>:
      raise (5);
      <D.35484>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35492 = alloc_dreg (cfg, D.31706);
      D.35493 = (int) D.35492;
      ins->dreg = D.35493;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35494>; else goto <D.35495>;
      <D.35494>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35496>;
      <D.35495>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35496>:
      sp.150 = sp;
      sp = sp.150 + 8;
      D.35498 = mono_decompose_opcode (cfg, ins);
      *sp.150 = D.35498;
      <D.35482>:
      ip = ip + 1;
      goto <D.27857>;
      <D.28201>:
      <D.28202>:
      <D.28203>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.35499>; else goto <D.35500>;
      <D.35499>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35501>; else goto <D.35502>;
      <D.35501>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35503>; else goto <D.35504>;
      <D.35503>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35504>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35502>:
      D.35505 = mini_get_debug_options ();
      D.35506 = D.35505->break_on_unverified;
      if (D.35506 != 0) goto <D.35507>; else goto unverified;
      <D.35507>:
      raise (5);
      <D.35500>:
      D.34772 = sp + 18446744073709551608;
      D.34773 = *D.34772;
      D.34774 = D.34773->type;
      if (D.34774 == 4) goto <D.35508>; else goto <D.35509>;
      <D.35508>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 186;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35510>; else goto <D.35511>;
      <D.35510>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35512>; else goto <D.35513>;
      <D.35512>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35514>; else goto <D.35515>;
      <D.35514>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35515>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35513>:
      D.35516 = mini_get_debug_options ();
      D.35517 = D.35516->break_on_unverified;
      if (D.35517 != 0) goto <D.35518>; else goto unverified;
      <D.35518>:
      raise (5);
      <D.35511>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35519 = alloc_dreg (cfg, D.31706);
      D.35520 = (int) D.35519;
      ins->dreg = D.35520;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35521>; else goto <D.35522>;
      <D.35521>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35523>;
      <D.35522>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35523>:
      sp.151 = sp;
      sp = sp.151 + 8;
      D.35525 = mono_decompose_opcode (cfg, ins);
      *sp.151 = D.35525;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35526>; else goto <D.35527>;
      <D.35526>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35528>; else goto <D.35529>;
      <D.35528>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35530>; else goto <D.35531>;
      <D.35530>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35531>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35529>:
      D.35532 = mini_get_debug_options ();
      D.35533 = D.35532->break_on_unverified;
      if (D.35533 != 0) goto <D.35534>; else goto unverified;
      <D.35534>:
      raise (5);
      <D.35527>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35535 = alloc_dreg (cfg, D.31706);
      D.35536 = (int) D.35535;
      ins->dreg = D.35536;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35537>; else goto <D.35538>;
      <D.35537>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35539>;
      <D.35538>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35539>:
      sp.152 = sp;
      sp = sp.152 + 8;
      D.35541 = mono_decompose_opcode (cfg, ins);
      *sp.152 = D.35541;
      goto <D.35542>;
      <D.35509>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35543>; else goto <D.35544>;
      <D.35543>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35545>; else goto <D.35546>;
      <D.35545>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35547>; else goto <D.35548>;
      <D.35547>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35548>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35546>:
      D.35549 = mini_get_debug_options ();
      D.35550 = D.35549->break_on_unverified;
      if (D.35550 != 0) goto <D.35551>; else goto unverified;
      <D.35551>:
      raise (5);
      <D.35544>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35552 = alloc_dreg (cfg, D.31706);
      D.35553 = (int) D.35552;
      ins->dreg = D.35553;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35554>; else goto <D.35555>;
      <D.35554>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35556>;
      <D.35555>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35556>:
      sp.153 = sp;
      sp = sp.153 + 8;
      D.35558 = mono_decompose_opcode (cfg, ins);
      *sp.153 = D.35558;
      <D.35542>:
      ip = ip + 1;
      goto <D.27857>;
      <D.28204>:
      <D.28205>:
      <D.28206>:
      <D.28207>:
      <D.28208>:
      <D.28209>:
      <D.28210>:
      <D.28211>:
      <D.28212>:
      <D.28213>:
      <D.28214>:
      <D.28215>:
      <D.28216>:
      <D.28217>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.35559>; else goto <D.35560>;
      <D.35559>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35561>; else goto <D.35562>;
      <D.35561>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35563>; else goto <D.35564>;
      <D.35563>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35564>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35562>:
      D.35565 = mini_get_debug_options ();
      D.35566 = D.35565->break_on_unverified;
      if (D.35566 != 0) goto <D.35567>; else goto unverified;
      <D.35567>:
      raise (5);
      <D.35560>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31957 = *sp;
      type_from_op (ins, D.31957, 0B);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35568>; else goto <D.35569>;
      <D.35568>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35570>; else goto <D.35571>;
      <D.35570>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35572>; else goto <D.35573>;
      <D.35572>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35573>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35571>:
      D.35574 = mini_get_debug_options ();
      D.35575 = D.35574->break_on_unverified;
      if (D.35575 != 0) goto <D.35576>; else goto unverified;
      <D.35576>:
      raise (5);
      <D.35569>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35577 = alloc_dreg (cfg, D.31706);
      D.35578 = (int) D.35577;
      ins->dreg = D.35578;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35579>; else goto <D.35580>;
      <D.35579>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35581>;
      <D.35580>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35581>:
      sp.154 = sp;
      sp = sp.154 + 8;
      D.35583 = mono_decompose_opcode (cfg, ins);
      *sp.154 = D.35583;
      D.31510 = cfg->exception_type;
      if (D.31510 != 0) goto exception_exit; else goto <D.35584>;
      <D.35584>:
      ip = ip + 1;
      goto <D.27857>;
      <D.28218>:
      <D.28219>:
      <D.28220>:
      <D.28221>:
      <D.28222>:
      <D.28223>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.35585>; else goto <D.35586>;
      <D.35585>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35587>; else goto <D.35588>;
      <D.35587>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35589>; else goto <D.35590>;
      <D.35589>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35590>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35588>:
      D.35591 = mini_get_debug_options ();
      D.35592 = D.35591->break_on_unverified;
      if (D.35592 != 0) goto <D.35593>; else goto unverified;
      <D.35593>:
      raise (5);
      <D.35586>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31838 = *ip;
      D.34621 = (short unsigned int) D.31838;
      ins->opcode = D.34621;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551600;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.33091 = D.33090->dreg;
      ins->sreg2 = D.33091;
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      type_from_op (ins, D.31957, D.33090);
      D.31705 = ins->type;
      if (D.31705 == 0) goto <D.35594>; else goto <D.35595>;
      <D.35594>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35596>; else goto <D.35597>;
      <D.35596>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35598>; else goto <D.35599>;
      <D.35598>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35599>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35597>:
      D.35600 = mini_get_debug_options ();
      D.35601 = D.35600->break_on_unverified;
      if (D.35601 != 0) goto <D.35602>; else goto unverified;
      <D.35602>:
      raise (5);
      <D.35595>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 == 3) goto <D.35603>; else goto <D.35604>;
      <D.35603>:
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.35360 = D.33090->type;
      if (D.35360 == 1) goto <D.35605>; else goto <D.35606>;
      <D.35605>:
      {
        struct MonoInst * widen;
        int dr;

        D.35607 = alloc_preg (cfg);
        dr = (int) D.35607;
        D.30941 = cfg->mempool;
        widen = mono_mempool_alloc (D.30941, 80);
        widen->data.op[1].const_val = 0;
        D.35608 = widen->data.op[1].const_val;
        widen->data.op[0].const_val = D.35608;
        widen->prev = 0B;
        D.35609 = widen->prev;
        widen->next = D.35609;
        widen->opcode = 762;
        widen->flags = 0;
        widen->type = 0;
        widen->dreg = -1;
        widen->sreg3 = -1;
        D.35610 = widen->sreg3;
        widen->sreg2 = D.35610;
        D.35611 = widen->sreg2;
        widen->sreg1 = D.35611;
        D.31162 = cfg->ip;
        widen->cil_code = D.31162;
        widen->dreg = dr;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        widen->sreg1 = D.33091;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35612>; else goto <D.35613>;
        <D.35612>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = widen;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        widen->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = widen;
        goto <D.35614>;
        <D.35613>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = widen;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35614>:
        D.35615 = widen->dreg;
        ins->sreg2 = D.35615;
      }
      <D.35606>:
      <D.35604>:
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.35616 = alloc_dreg (cfg, D.31706);
      D.35617 = (int) D.35616;
      ins->dreg = D.35617;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35618>; else goto <D.35619>;
      <D.35618>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35620>;
      <D.35619>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35620>:
      sp.155 = sp;
      sp = sp.155 + 8;
      D.35622 = mono_decompose_opcode (cfg, ins);
      *sp.155 = D.35622;
      ip = ip + 1;
      goto <D.27857>;
      <D.28226>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35623>; else goto <D.35624>;
      <D.35623>:
      D.30878 = method->klass;
      D.32629 = D.30878->name_space;
      D.30878 = method->klass;
      D.32630 = D.30878->name;
      D.32631 = method->name;
      D.32632 = method->signature;
      D.32633 = D.32632->param_count;
      D.32634 = (int) D.32633;
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      D.35625 = mono_opcode_name (D.31839);
      D.35626 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.35625, "method-to-ir.c", 9069);
      cfg->exception_message = D.35626;
      D.31021 = cfg->verbose_level;
      if (D.31021 > 1) goto <D.35627>; else goto <D.35628>;
      <D.35627>:
      D.32639 = cfg->exception_message;
      printf ("%s\n", D.32639);
      <D.35628>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35624>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.35629>; else goto <D.35630>;
      <D.35629>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35631>; else goto <D.35632>;
      <D.35631>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35633>; else goto <D.35634>;
      <D.35633>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35634>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35632>:
      D.35635 = mini_get_debug_options ();
      D.35636 = D.35635->break_on_unverified;
      if (D.35636 != 0) goto <D.35637>; else goto unverified;
      <D.35637>:
      raise (5);
      <D.35630>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.35638>; else goto <D.35639>;
      <D.35638>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35640>; else goto <D.35641>;
      <D.35640>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35642>; else goto <D.35643>;
      <D.35642>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35643>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35641>:
      D.35644 = mini_get_debug_options ();
      D.35645 = D.35644->break_on_unverified;
      if (D.35645 != 0) goto <D.35646>; else goto unverified;
      <D.35646>:
      raise (5);
      <D.35639>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.156 = mini_get_class (method, token, generic_context);
      klass = klass.156;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.35648>; else goto <D.35651>;
      <D.35651>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.35648>; else goto <D.35649>;
      <D.35648>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.35653 = mini_get_debug_options ();
      D.35654 = D.35653->break_on_unverified;
      if (D.35654 != 0) goto <D.35655>; else goto load_error;
      <D.35655>:
      raise (5);
      <D.35649>:
      sp = sp + 18446744073709551600;
      klass.157 = klass;
      D.35656 = generic_class_is_reference_type (cfg, klass.157);
      if (D.35656 != 0) goto <D.35657>; else goto <D.35658>;
      <D.35657>:
      {
        struct MonoInst * store;
        struct MonoInst * load;
        int dreg;

        D.35659 = alloc_ireg_ref (cfg);
        dreg = (int) D.35659;
        D.30941 = cfg->mempool;
        load = mono_mempool_alloc (D.30941, 80);
        load->data.op[1].const_val = 0;
        D.35660 = load->data.op[1].const_val;
        load->data.op[0].const_val = D.35660;
        load->prev = 0B;
        D.35661 = load->prev;
        load->next = D.35661;
        load->opcode = 388;
        load->flags = 0;
        load->type = 0;
        load->dreg = -1;
        load->sreg3 = -1;
        D.35662 = load->sreg3;
        load->sreg2 = D.35662;
        D.35663 = load->sreg2;
        load->sreg1 = D.35663;
        D.31162 = cfg->ip;
        load->cil_code = D.31162;
        load->dreg = dreg;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        load->sreg1 = D.33091;
        load->data.op[0].const_val = 0;
        load->type = 1;
        D.35664 = load->flags;
        D.35267 = (unsigned char) ins_flag;
        D.35665 = D.35664 | D.35267;
        load->flags = D.35665;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35666>; else goto <D.35667>;
        <D.35666>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = load;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        load->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = load;
        goto <D.35668>;
        <D.35667>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = load;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35668>:
        D.30941 = cfg->mempool;
        store = mono_mempool_alloc (D.30941, 80);
        store->data.op[1].const_val = 0;
        D.35669 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.35669;
        store->prev = 0B;
        D.35670 = store->prev;
        store->next = D.35670;
        store->opcode = 374;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.35671 = store->sreg3;
        store->sreg2 = D.35671;
        D.35672 = store->sreg2;
        store->sreg1 = D.35672;
        D.31162 = cfg->ip;
        store->cil_code = D.31162;
        store->sreg1 = dreg;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        store->dreg = D.32139;
        store->data.op[0].const_val = 0;
        D.35673 = store->flags;
        D.35267 = (unsigned char) ins_flag;
        D.35674 = D.35673 | D.35267;
        store->flags = D.35674;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35675>; else goto <D.35676>;
        <D.35675>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = store;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        store->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        goto <D.35677>;
        <D.35676>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35677>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.34146 = D.31336 & 1152921504606846976;
        if (D.34146 != 0) goto <D.35678>; else goto <D.35679>;
        <D.35678>:
        D.30911 = cfg->method;
        D.32877 = BIT_FIELD_REF <*D.30911, 64, 256>;
        D.32878 = D.32877 & 124;
        if (D.32878 != 96) goto <D.35680>; else goto <D.35681>;
        <D.35680>:
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        emit_write_barrier (cfg, D.31957, D.33090);
        <D.35681>:
        <D.35679>:
      }
      goto <D.35682>;
      <D.35658>:
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      klass.157 = klass;
      mini_emit_stobj (cfg, D.31957, D.33090, klass.157, 0);
      <D.35682>:
      ins_flag = 0;
      ip = ip + 5;
      goto <D.27857>;
      <D.28230>:
      {
        int loc_index;
        int stloc_len;

        loc_index = -1;
        stloc_len = 0;
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.35683>; else goto <D.35684>;
        <D.35683>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35685>; else goto <D.35686>;
        <D.35685>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35687>; else goto <D.35688>;
        <D.35687>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35688>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35686>:
        D.35689 = mini_get_debug_options ();
        D.35690 = D.35689->break_on_unverified;
        if (D.35690 != 0) goto <D.35691>; else goto unverified;
        <D.35691>:
        raise (5);
        <D.35684>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.35692>; else goto <D.35693>;
        <D.35692>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35694>; else goto <D.35695>;
        <D.35694>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35696>; else goto <D.35697>;
        <D.35696>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35697>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35695>:
        D.35698 = mini_get_debug_options ();
        D.35699 = D.35698->break_on_unverified;
        if (D.35699 != 0) goto <D.35700>; else goto unverified;
        <D.35700>:
        raise (5);
        <D.35693>:
        sp = sp + 18446744073709551608;
        token = MEM[(const guint32 *)ip + 1B];
        klass.158 = mini_get_class (method, token, generic_context);
        klass = klass.158;
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.35702>; else goto <D.35704>;
        <D.35704>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.35702>; else goto <D.35703>;
        <D.35702>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.35705 = mini_get_debug_options ();
        D.35706 = D.35705->break_on_unverified;
        if (D.35706 != 0) goto <D.35707>; else goto load_error;
        <D.35707>:
        raise (5);
        <D.35703>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        D.35708 = (int) D.32923;
        switch (D.35708) <default: <D.28239>, case 10: <D.28235>, case 11: <D.28236>, case 12: <D.28237>, case 13: <D.28238>, case 19: <D.28233>>
        <D.28233>:
        D.35709 = ip + 6;
        D.35710 = *D.35709;
        loc_index = (int) D.35710;
        stloc_len = 2;
        goto <D.28234>;
        <D.28235>:
        <D.28236>:
        <D.28237>:
        <D.28238>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        D.35708 = (int) D.32923;
        loc_index = D.35708 + -10;
        stloc_len = 1;
        goto <D.28234>;
        <D.28239>:
        goto <D.28234>;
        <D.28234>:
        if (loc_index != -1) goto <D.35711>; else goto <D.35712>;
        <D.35711>:
        bblock.70 = bblock;
        D.33876 = ip + 5;
        D.35713 = ip_in_bb (cfg, bblock.70, D.33876);
        if (D.35713 != 0) goto <D.35714>; else goto <D.35715>;
        <D.35714>:
        loc_index.159 = (unsigned int) loc_index;
        D.31546 = header->num_locals;
        D.31911 = (unsigned int) D.31546;
        if (loc_index.159 >= D.31911) goto <D.35717>; else goto <D.35718>;
        <D.35717>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35719>; else goto <D.35720>;
        <D.35719>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35721>; else goto <D.35722>;
        <D.35721>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35722>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35720>:
        D.35723 = mini_get_debug_options ();
        D.35724 = D.35723->break_on_unverified;
        if (D.35724 != 0) goto <D.35725>; else goto unverified;
        <D.35725>:
        raise (5);
        <D.35718>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        D.35727 = mono_type_to_load_membase (cfg, D.35726);
        D.35728 = (short unsigned int) D.35727;
        ins->opcode = D.35728;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = 0;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        ins->sreg1 = D.32139;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        type_to_eval_stack_type (cfg, D.35726, ins);
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.35729 = alloc_dreg (cfg, D.31706);
        D.35730 = (int) D.35729;
        ins->dreg = D.35730;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35731>; else goto <D.35732>;
        <D.35731>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.35733>;
        <D.35732>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35733>:
        D.31923 = cfg->locals;
        D.35734 = (long unsigned int) loc_index;
        D.35735 = D.35734 * 8;
        D.35736 = D.31923 + D.35735;
        D.35737 = *D.35736;
        D.35738 = D.35737->dreg;
        ins->dreg = D.35738;
        ip = ip + 5;
        D.35739 = (sizetype) stloc_len;
        ip = ip + D.35739;
        goto <D.27857>;
        <D.35715>:
        <D.35712>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        if (D.32923 == 129) goto <D.35740>; else goto <D.35741>;
        <D.35740>:
        bblock.70 = bblock;
        D.33876 = ip + 5;
        D.35742 = ip_in_bb (cfg, bblock.70, D.33876);
        if (D.35742 != 0) goto <D.35743>; else goto <D.35744>;
        <D.35743>:
        D.35745 = ip + 6;
        D.35746 = *D.35745;
        if (D.35746 == token) goto <D.35747>; else goto <D.35748>;
        <D.35747>:
        klass.157 = klass;
        D.35749 = generic_class_is_reference_type (cfg, klass.157);
        if (D.35749 == 0) goto <D.35750>; else goto <D.35751>;
        <D.35750>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.35752>; else goto <D.35753>;
        <D.35752>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.35754>; else goto <D.35755>;
        <D.35754>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.35756>; else goto <D.35757>;
        <D.35756>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35757>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35755>:
        D.35758 = mini_get_debug_options ();
        D.35759 = D.35758->break_on_unverified;
        if (D.35759 != 0) goto <D.35760>; else goto unverified;
        <D.35760>:
        raise (5);
        <D.35753>:
        sp = sp + 18446744073709551608;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        klass.157 = klass;
        mini_emit_stobj (cfg, D.31957, D.33090, klass.157, 0);
        ip = ip + 10;
        ins_flag = 0;
        goto <D.27857>;
        <D.35751>:
        <D.35748>:
        <D.35744>:
        <D.35741>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        D.35761 = mono_type_to_load_membase (cfg, D.35726);
        D.35762 = (short unsigned int) D.35761;
        ins->opcode = D.35762;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = 0;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        ins->sreg1 = D.32139;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        type_to_eval_stack_type (cfg, D.35726, ins);
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.35763 = alloc_dreg (cfg, D.31706);
        D.35764 = (int) D.35763;
        ins->dreg = D.35764;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.35765>; else goto <D.35766>;
        <D.35765>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.35767>;
        <D.35766>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.35767>:
        sp.160 = sp;
        sp = sp.160 + 8;
        *sp.160 = ins;
        ip = ip + 5;
        ins_flag = 0;
        inline_costs = inline_costs + 1;
        goto <D.27857>;
      }
      <D.28240>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.35769>; else goto <D.35770>;
      <D.35769>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35771>; else goto <D.35772>;
      <D.35771>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35773>; else goto <D.35774>;
      <D.35773>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35774>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35772>:
      D.35775 = mini_get_debug_options ();
      D.35776 = D.35775->break_on_unverified;
      if (D.35776 != 0) goto <D.35777>; else goto unverified;
      <D.35777>:
      raise (5);
      <D.35770>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.35778>; else goto <D.35779>;
      <D.35778>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.35780>; else goto <D.35781>;
      <D.35780>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.35782>; else goto <D.35783>;
      <D.35782>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35783>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35781>:
      D.35784 = mini_get_debug_options ();
      D.35785 = D.35784->break_on_unverified;
      if (D.35785 != 0) goto <D.35786>; else goto unverified;
      <D.35786>:
      raise (5);
      <D.35779>:
      D.32400 = ip + 1;
      D.32401 = *D.32400;
      n = (int) D.32401;
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 68) goto <D.35787>; else goto <D.35788>;
      <D.35787>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      n.161 = (unsigned int) n;
      D.35790 = mono_method_get_wrapper_data (method, n.161);
      ins->data.op[0].p = D.35790;
      ins->type = 3;
      D.35791 = alloc_dreg (cfg, 3);
      D.35792 = (int) D.35791;
      ins->dreg = D.35792;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.35793>; else goto <D.35794>;
      <D.35793>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.35795>;
      <D.35794>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.35795>:
      ins->type = 6;
      *sp = ins;
      goto <D.35796>;
      <D.35788>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 != 0) goto <D.35797>; else goto <D.35798>;
      <D.35797>:
      {
        struct MonoInst * iargs[1];

        try
          {
            D.30941 = cfg->mempool;
            D.35799 = mono_mempool_alloc (D.30941, 80);
            iargs[0] = D.35799;
            D.35800 = iargs[0];
            D.35800 = iargs[0];
            D.35800->data.op[1].const_val = 0;
            D.35801 = D.35800->data.op[1].const_val;
            D.35800->data.op[0].const_val = D.35801;
            D.35800 = iargs[0];
            D.35800 = iargs[0];
            D.35800->prev = 0B;
            D.35802 = D.35800->prev;
            D.35800->next = D.35802;
            D.35800 = iargs[0];
            D.35800->opcode = 363;
            D.35800 = iargs[0];
            D.35800->flags = 0;
            D.35800 = iargs[0];
            D.35800->type = 0;
            D.35800 = iargs[0];
            D.35800->dreg = -1;
            D.35800 = iargs[0];
            D.35800 = iargs[0];
            D.35800 = iargs[0];
            D.35800->sreg3 = -1;
            D.35803 = D.35800->sreg3;
            D.35800->sreg2 = D.35803;
            D.35804 = D.35800->sreg2;
            D.35800->sreg1 = D.35804;
            D.35800 = iargs[0];
            D.31162 = cfg->ip;
            D.35800->cil_code = D.31162;
            D.35800 = iargs[0];
            n.161 = (unsigned int) n;
            D.35805 = mono_method_get_wrapper_data (method, n.161);
            D.35800->data.op[0].p = D.35805;
            D.35800 = iargs[0];
            D.35800->type = 3;
            D.35800 = iargs[0];
            D.35806 = alloc_dreg (cfg, 3);
            D.35807 = (int) D.35806;
            D.35800->dreg = D.35807;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35808>; else goto <D.35809>;
            <D.35808>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35800 = iargs[0];
            D.31191->next = D.35800;
            D.35800 = iargs[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35800->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35800 = iargs[0];
            bblock.113->last_ins = D.35800;
            goto <D.35810>;
            <D.35809>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35800 = iargs[0];
            bblock.113->last_ins = D.35800;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35810>:
            D.35811 = mono_emit_jit_icall (cfg, mono_string_new_wrapper, &iargs);
            *sp = D.35811;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35812>;
      <D.35798>:
      D.31334 = cfg->opt;
      D.31335 = D.31334 & 512;
      if (D.31335 != 0) goto <D.35813>; else goto <D.35814>;
      <D.35813>:
      {
        struct MonoInst * iargs[3];

        try
          {
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35815>; else goto <D.35816>;
            <D.35815>:
            D.35817 = cfg->ldstr_list;
            D.32978 = (long int) n;
            D.35818 = (void *) D.32978;
            D.35819 = monoeg_g_list_prepend (D.35817, D.35818);
            cfg->ldstr_list = D.35819;
            <D.35816>:
            D.31334 = cfg->opt;
            D.31335 = D.31334 & 512;
            if (D.31335 != 0) goto <D.35820>; else goto <D.35823>;
            <D.35823>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35820>; else goto <D.35821>;
            <D.35820>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.30941 = cfg->mempool;
              D.35824 = mono_mempool_alloc (D.30941, 80);
              iargs[0] = D.35824;
              D.35825 = iargs[0];
              D.35825 = iargs[0];
              D.35825->data.op[1].const_val = 0;
              D.35826 = D.35825->data.op[1].const_val;
              D.35825->data.op[0].const_val = D.35826;
              D.35825 = iargs[0];
              D.35825 = iargs[0];
              D.35825->prev = 0B;
              D.35827 = D.35825->prev;
              D.35825->next = D.35827;
              D.35825 = iargs[0];
              D.35825->opcode = 424;
              D.35825 = iargs[0];
              D.35825->flags = 0;
              D.35825 = iargs[0];
              D.35825->type = 0;
              D.35825 = iargs[0];
              D.35825->dreg = -1;
              D.35825 = iargs[0];
              D.35825 = iargs[0];
              D.35825 = iargs[0];
              D.35825->sreg3 = -1;
              D.35828 = D.35825->sreg3;
              D.35825->sreg2 = D.35828;
              D.35829 = D.35825->sreg2;
              D.35825->sreg1 = D.35829;
              D.35825 = iargs[0];
              D.31162 = cfg->ip;
              D.35825->cil_code = D.31162;
              D.35825 = iargs[0];
              D.31695 = cfg->varinfo;
              D.35830 = __domain_var->data.op[0].const_val;
              D.35831 = (long unsigned int) D.35830;
              D.35832 = D.35831 * 8;
              D.35833 = D.31695 + D.35832;
              D.35834 = *D.35833;
              D.35835 = D.35834->data.op[1].vtype;
              D.35836 = mono_type_to_regmove (cfg, D.35835);
              D.35837 = (short unsigned int) D.35836;
              D.35825->opcode = D.35837;
              D.31695 = cfg->varinfo;
              D.35830 = __domain_var->data.op[0].const_val;
              D.35831 = (long unsigned int) D.35830;
              D.35832 = D.35831 * 8;
              D.35833 = D.31695 + D.35832;
              D.35834 = *D.35833;
              D.35835 = D.35834->data.op[1].vtype;
              D.35825 = iargs[0];
              type_to_eval_stack_type (cfg, D.35835, D.35825);
              D.35825 = iargs[0];
              D.31695 = cfg->varinfo;
              D.35830 = __domain_var->data.op[0].const_val;
              D.35831 = (long unsigned int) D.35830;
              D.35832 = D.35831 * 8;
              D.35833 = D.31695 + D.35832;
              D.35834 = *D.35833;
              D.35838 = D.35834->klass;
              D.35825->klass = D.35838;
              D.35825 = iargs[0];
              D.31695 = cfg->varinfo;
              D.35830 = __domain_var->data.op[0].const_val;
              D.35831 = (long unsigned int) D.35830;
              D.35832 = D.35831 * 8;
              D.35833 = D.31695 + D.35832;
              D.35834 = *D.35833;
              D.35839 = D.35834->dreg;
              D.35825->sreg1 = D.35839;
              D.35825 = iargs[0];
              D.35825 = iargs[0];
              D.35840 = D.35825->type;
              D.35841 = (<unnamed type>) D.35840;
              D.35842 = alloc_dreg (cfg, D.35841);
              D.35843 = (int) D.35842;
              D.35825->dreg = D.35843;
              D.35825 = iargs[0];
              D.35844 = D.35825->opcode;
              if (D.35844 == 427) goto <D.35845>; else goto <D.35846>;
              <D.35845>:
              D.35825 = iargs[0];
              D.31695 = cfg->varinfo;
              D.35830 = __domain_var->data.op[0].const_val;
              D.35831 = (long unsigned int) D.35830;
              D.35832 = D.35831 * 8;
              D.35833 = D.31695 + D.35832;
              D.35834 = *D.35833;
              D.35835 = D.35834->data.op[1].vtype;
              D.35847 = mono_class_from_mono_type (D.35835);
              D.35825->klass = D.35847;
              <D.35846>:
            }
            goto <D.35822>;
            <D.35821>:
            D.30941 = cfg->mempool;
            D.35848 = mono_mempool_alloc (D.30941, 80);
            iargs[0] = D.35848;
            D.35825 = iargs[0];
            D.35825 = iargs[0];
            D.35825->data.op[1].const_val = 0;
            D.35826 = D.35825->data.op[1].const_val;
            D.35825->data.op[0].const_val = D.35826;
            D.35825 = iargs[0];
            D.35825 = iargs[0];
            D.35825->prev = 0B;
            D.35827 = D.35825->prev;
            D.35825->next = D.35827;
            D.35825 = iargs[0];
            D.35825->opcode = 363;
            D.35825 = iargs[0];
            D.35825->flags = 0;
            D.35825 = iargs[0];
            D.35825->type = 0;
            D.35825 = iargs[0];
            D.35825->dreg = -1;
            D.35825 = iargs[0];
            D.35825 = iargs[0];
            D.35825 = iargs[0];
            D.35825->sreg3 = -1;
            D.35828 = D.35825->sreg3;
            D.35825->sreg2 = D.35828;
            D.35829 = D.35825->sreg2;
            D.35825->sreg1 = D.35829;
            D.35825 = iargs[0];
            D.31162 = cfg->ip;
            D.35825->cil_code = D.31162;
            D.35825 = iargs[0];
            D.30966 = cfg->domain;
            D.35825->data.op[0].p = D.30966;
            D.35825 = iargs[0];
            D.35825->type = 3;
            D.35825 = iargs[0];
            D.35849 = alloc_dreg (cfg, 3);
            D.35850 = (int) D.35849;
            D.35825->dreg = D.35850;
            <D.35822>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35851>; else goto <D.35852>;
            <D.35851>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35825 = iargs[0];
            D.31191->next = D.35825;
            D.35825 = iargs[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35825->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35825 = iargs[0];
            bblock.113->last_ins = D.35825;
            goto <D.35853>;
            <D.35852>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35825 = iargs[0];
            bblock.113->last_ins = D.35825;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35853>:
            D.30941 = cfg->mempool;
            D.35854 = mono_mempool_alloc (D.30941, 80);
            iargs[1] = D.35854;
            D.35855 = iargs[1];
            D.35855 = iargs[1];
            D.35855->data.op[1].const_val = 0;
            D.35856 = D.35855->data.op[1].const_val;
            D.35855->data.op[0].const_val = D.35856;
            D.35855 = iargs[1];
            D.35855 = iargs[1];
            D.35855->prev = 0B;
            D.35857 = D.35855->prev;
            D.35855->next = D.35857;
            D.35855 = iargs[1];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35859>; else goto <D.35860>;
            <D.35859>:
            iftmp.162 = 734;
            goto <D.35861>;
            <D.35860>:
            iftmp.162 = 363;
            <D.35861>:
            D.35855->opcode = iftmp.162;
            D.35855 = iargs[1];
            D.35855->flags = 0;
            D.35855 = iargs[1];
            D.35855->type = 0;
            D.35855 = iargs[1];
            D.35855->dreg = -1;
            D.35855 = iargs[1];
            D.35855 = iargs[1];
            D.35855 = iargs[1];
            D.35855->sreg3 = -1;
            D.35862 = D.35855->sreg3;
            D.35855->sreg2 = D.35862;
            D.35863 = D.35855->sreg2;
            D.35855->sreg1 = D.35863;
            D.35855 = iargs[1];
            D.31162 = cfg->ip;
            D.35855->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35864>; else goto <D.35865>;
            <D.35864>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.35866 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.35866;
              group->prev = 0B;
              D.35867 = group->prev;
              group->next = D.35867;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.35868 = group->sreg3;
              group->sreg2 = D.35868;
              D.35869 = group->sreg2;
              group->sreg1 = D.35869;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = image;
              group->data.op[1].src = 12B;
              D.35855 = iargs[1];
              D.35870 = got_loc->dreg;
              D.35855->sreg1 = D.35870;
              D.35855 = iargs[1];
              D.35855->data.op[1].p = group;
            }
            goto <D.35871>;
            <D.35865>:
            D.35855 = iargs[1];
            D.35855->data.op[0].p = image;
            D.35855 = iargs[1];
            D.35855->data.op[1].src = 12B;
            <D.35871>:
            D.35855 = iargs[1];
            D.35855->type = 3;
            D.35855 = iargs[1];
            D.35872 = alloc_dreg (cfg, 3);
            D.35873 = (int) D.35872;
            D.35855->dreg = D.35873;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35874>; else goto <D.35875>;
            <D.35874>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35855 = iargs[1];
            D.31191->next = D.35855;
            D.35855 = iargs[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35855->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35855 = iargs[1];
            bblock.113->last_ins = D.35855;
            goto <D.35876>;
            <D.35875>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35855 = iargs[1];
            bblock.113->last_ins = D.35855;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35876>:
            D.30941 = cfg->mempool;
            D.35877 = mono_mempool_alloc (D.30941, 80);
            iargs[2] = D.35877;
            D.35878 = iargs[2];
            D.35878 = iargs[2];
            D.35878->data.op[1].const_val = 0;
            D.35879 = D.35878->data.op[1].const_val;
            D.35878->data.op[0].const_val = D.35879;
            D.35878 = iargs[2];
            D.35878 = iargs[2];
            D.35878->prev = 0B;
            D.35880 = D.35878->prev;
            D.35878->next = D.35880;
            D.35878 = iargs[2];
            D.35878->opcode = 362;
            D.35878 = iargs[2];
            D.35878->flags = 0;
            D.35878 = iargs[2];
            D.35878->type = 0;
            D.35878 = iargs[2];
            D.35878->dreg = -1;
            D.35878 = iargs[2];
            D.35878 = iargs[2];
            D.35878 = iargs[2];
            D.35878->sreg3 = -1;
            D.35881 = D.35878->sreg3;
            D.35878->sreg2 = D.35881;
            D.35882 = D.35878->sreg2;
            D.35878->sreg1 = D.35882;
            D.35878 = iargs[2];
            D.31162 = cfg->ip;
            D.35878->cil_code = D.31162;
            D.35878 = iargs[2];
            n.163 = (unsigned int) n;
            D.35884 = (long int) n.163;
            D.35885 = D.35884 & 16777215;
            D.35878->data.op[0].const_val = D.35885;
            D.35878 = iargs[2];
            D.35878->type = 1;
            D.35878 = iargs[2];
            D.35886 = alloc_dreg (cfg, 1);
            D.35887 = (int) D.35886;
            D.35878->dreg = D.35887;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35888>; else goto <D.35889>;
            <D.35888>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35878 = iargs[2];
            D.31191->next = D.35878;
            D.35878 = iargs[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35878->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35878 = iargs[2];
            bblock.113->last_ins = D.35878;
            goto <D.35890>;
            <D.35889>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35878 = iargs[2];
            bblock.113->last_ins = D.35878;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35890>:
            D.35891 = mono_emit_jit_icall (cfg, mono_ldstr, &iargs);
            *sp = D.35891;
            D.30966 = cfg->domain;
            n.164 = (unsigned int) n;
            D.35893 = n.164 & 16777215;
            mono_ldstr (D.30966, image, D.35893);
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35894>;
      <D.35814>:
      bblock.70 = bblock;
      D.35895 = BIT_FIELD_REF <*bblock.70, 64, 1472>;
      D.35896 = D.35895 & 65536;
      if (D.35896 != 0) goto <D.35897>; else goto <D.35898>;
      <D.35897>:
      {
        struct MonoInst * iargs[2];

        try
          {
            D.33005 = mono_defaults.corlib;
            if (D.33005 == image) goto <D.35899>; else goto <D.35900>;
            <D.35899>:
            D.30941 = cfg->mempool;
            D.35901 = mono_mempool_alloc (D.30941, 80);
            iargs[0] = D.35901;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->data.op[1].const_val = 0;
            D.35903 = D.35902->data.op[1].const_val;
            D.35902->data.op[0].const_val = D.35903;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->prev = 0B;
            D.35904 = D.35902->prev;
            D.35902->next = D.35904;
            D.35902 = iargs[0];
            D.35902->opcode = 362;
            D.35902 = iargs[0];
            D.35902->flags = 0;
            D.35902 = iargs[0];
            D.35902->type = 0;
            D.35902 = iargs[0];
            D.35902->dreg = -1;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->sreg3 = -1;
            D.35905 = D.35902->sreg3;
            D.35902->sreg2 = D.35905;
            D.35906 = D.35902->sreg2;
            D.35902->sreg1 = D.35906;
            D.35902 = iargs[0];
            D.31162 = cfg->ip;
            D.35902->cil_code = D.31162;
            D.35902 = iargs[0];
            n.163 = (unsigned int) n;
            D.35884 = (long int) n.163;
            D.35885 = D.35884 & 16777215;
            D.35902->data.op[0].const_val = D.35885;
            D.35902 = iargs[0];
            D.35902->type = 1;
            D.35902 = iargs[0];
            D.35907 = alloc_dreg (cfg, 1);
            D.35908 = (int) D.35907;
            D.35902->dreg = D.35908;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35909>; else goto <D.35910>;
            <D.35909>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35902 = iargs[0];
            D.31191->next = D.35902;
            D.35902 = iargs[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35902->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35902 = iargs[0];
            bblock.113->last_ins = D.35902;
            goto <D.35911>;
            <D.35910>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35902 = iargs[0];
            bblock.113->last_ins = D.35902;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35911>:
            D.35912 = mono_emit_jit_icall (cfg, mono_helper_ldstr_mscorlib, &iargs);
            *sp = D.35912;
            goto <D.35913>;
            <D.35900>:
            D.30941 = cfg->mempool;
            D.35914 = mono_mempool_alloc (D.30941, 80);
            iargs[0] = D.35914;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->data.op[1].const_val = 0;
            D.35903 = D.35902->data.op[1].const_val;
            D.35902->data.op[0].const_val = D.35903;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->prev = 0B;
            D.35904 = D.35902->prev;
            D.35902->next = D.35904;
            D.35902 = iargs[0];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35916>; else goto <D.35917>;
            <D.35916>:
            iftmp.165 = 734;
            goto <D.35918>;
            <D.35917>:
            iftmp.165 = 363;
            <D.35918>:
            D.35902->opcode = iftmp.165;
            D.35902 = iargs[0];
            D.35902->flags = 0;
            D.35902 = iargs[0];
            D.35902->type = 0;
            D.35902 = iargs[0];
            D.35902->dreg = -1;
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902 = iargs[0];
            D.35902->sreg3 = -1;
            D.35905 = D.35902->sreg3;
            D.35902->sreg2 = D.35905;
            D.35906 = D.35902->sreg2;
            D.35902->sreg1 = D.35906;
            D.35902 = iargs[0];
            D.31162 = cfg->ip;
            D.35902->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.35919>; else goto <D.35920>;
            <D.35919>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.35921 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.35921;
              group->prev = 0B;
              D.35922 = group->prev;
              group->next = D.35922;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.35923 = group->sreg3;
              group->sreg2 = D.35923;
              D.35924 = group->sreg2;
              group->sreg1 = D.35924;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = image;
              group->data.op[1].src = 12B;
              D.35902 = iargs[0];
              D.35925 = got_loc->dreg;
              D.35902->sreg1 = D.35925;
              D.35902 = iargs[0];
              D.35902->data.op[1].p = group;
            }
            goto <D.35926>;
            <D.35920>:
            D.35902 = iargs[0];
            D.35902->data.op[0].p = image;
            D.35902 = iargs[0];
            D.35902->data.op[1].src = 12B;
            <D.35926>:
            D.35902 = iargs[0];
            D.35902->type = 3;
            D.35902 = iargs[0];
            D.35927 = alloc_dreg (cfg, 3);
            D.35928 = (int) D.35927;
            D.35902->dreg = D.35928;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35929>; else goto <D.35930>;
            <D.35929>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35902 = iargs[0];
            D.31191->next = D.35902;
            D.35902 = iargs[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35902->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35902 = iargs[0];
            bblock.113->last_ins = D.35902;
            goto <D.35931>;
            <D.35930>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35902 = iargs[0];
            bblock.113->last_ins = D.35902;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35931>:
            D.30941 = cfg->mempool;
            D.35932 = mono_mempool_alloc (D.30941, 80);
            iargs[1] = D.35932;
            D.35933 = iargs[1];
            D.35933 = iargs[1];
            D.35933->data.op[1].const_val = 0;
            D.35934 = D.35933->data.op[1].const_val;
            D.35933->data.op[0].const_val = D.35934;
            D.35933 = iargs[1];
            D.35933 = iargs[1];
            D.35933->prev = 0B;
            D.35935 = D.35933->prev;
            D.35933->next = D.35935;
            D.35933 = iargs[1];
            D.35933->opcode = 362;
            D.35933 = iargs[1];
            D.35933->flags = 0;
            D.35933 = iargs[1];
            D.35933->type = 0;
            D.35933 = iargs[1];
            D.35933->dreg = -1;
            D.35933 = iargs[1];
            D.35933 = iargs[1];
            D.35933 = iargs[1];
            D.35933->sreg3 = -1;
            D.35936 = D.35933->sreg3;
            D.35933->sreg2 = D.35936;
            D.35937 = D.35933->sreg2;
            D.35933->sreg1 = D.35937;
            D.35933 = iargs[1];
            D.31162 = cfg->ip;
            D.35933->cil_code = D.31162;
            D.35933 = iargs[1];
            n.163 = (unsigned int) n;
            D.35884 = (long int) n.163;
            D.35885 = D.35884 & 16777215;
            D.35933->data.op[0].const_val = D.35885;
            D.35933 = iargs[1];
            D.35933->type = 1;
            D.35933 = iargs[1];
            D.35938 = alloc_dreg (cfg, 1);
            D.35939 = (int) D.35938;
            D.35933->dreg = D.35939;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.35940>; else goto <D.35941>;
            <D.35940>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35933 = iargs[1];
            D.31191->next = D.35933;
            D.35933 = iargs[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35933->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.35933 = iargs[1];
            bblock.113->last_ins = D.35933;
            goto <D.35942>;
            <D.35941>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.35933 = iargs[1];
            bblock.113->last_ins = D.35933;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.35942>:
            D.35943 = mono_emit_jit_icall (cfg, mono_helper_ldstr, &iargs);
            *sp = D.35943;
            <D.35913>:
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35944>;
      <D.35898>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31337 = D.31336 & 274877906944;
      if (D.31337 != 0) goto <D.35945>; else goto <D.35946>;
      <D.35945>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 734;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        got_loc = mono_get_got_var (cfg);
        D.30941 = cfg->mempool;
        group = mono_mempool_alloc (D.30941, 80);
        group->data.op[1].const_val = 0;
        D.35947 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.35947;
        group->prev = 0B;
        D.35948 = group->prev;
        group->next = D.35948;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.35949 = group->sreg3;
        group->sreg2 = D.35949;
        D.35950 = group->sreg2;
        group->sreg1 = D.35950;
        D.31162 = cfg->ip;
        group->cil_code = D.31162;
        group->data.op[0].src = 0B;
        group->data.op[1].src = 17B;
        D.30941 = cfg->mempool;
        n.161 = (unsigned int) n;
        D.35951 = mono_jump_info_token_new2 (D.30941, image, n.161, 0B);
        group->data.op[0].p = D.35951;
        D.35952 = got_loc->dreg;
        ins->sreg1 = D.35952;
        ins->data.op[1].p = group;
        ins->type = 6;
        D.35953 = mono_defaults.string_class;
        ins->klass = D.35953;
        D.35954 = alloc_dreg (cfg, 6);
        D.35955 = (int) D.35954;
        ins->dreg = D.35955;
      }
      *sp = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.35956>; else goto <D.35957>;
      <D.35956>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.35958>;
      <D.35957>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.35958>:
      goto <D.35959>;
      <D.35946>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[0].p = 0B;
      ins->type = 3;
      D.35960 = alloc_dreg (cfg, 3);
      D.35961 = (int) D.35960;
      ins->dreg = D.35961;
      ins->type = 6;
      D.30966 = cfg->domain;
      n.164 = (unsigned int) n;
      D.35893 = n.164 & 16777215;
      D.35962 = mono_ldstr (D.30966, image, D.35893);
      ins->data.op[0].p = D.35962;
      D.35963 = ins->data.op[0].p;
      if (D.35963 == 0B) goto <D.35964>; else goto <D.35965>;
      <D.35964>:
      mono_cfg_set_exception (cfg, 14);
      goto exception_exit;
      <D.35965>:
      *sp = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.35966>; else goto <D.35967>;
      <D.35966>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.35968>;
      <D.35967>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.35968>:
      <D.35959>:
      <D.35944>:
      <D.35894>:
      <D.35812>:
      <D.35796>:
      sp = sp + 8;
      ip = ip + 5;
      goto <D.27857>;
      <D.28251>:
      {
        struct MonoInst * iargs[2];
        struct MonoMethodSignature * fsig;
        struct MonoInst this_ins;
        struct MonoInst * alloc;
        struct MonoInst * vtable_arg;

        try
          {
            vtable_arg = 0B;
            D.32381 = ip + 5;
            if (D.32381 > end) goto <D.35969>; else goto <D.35970>;
            <D.35969>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.35971>; else goto <D.35972>;
            <D.35971>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.35973>; else goto <D.35974>;
            <D.35973>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.35974>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.35972>:
            D.35975 = mini_get_debug_options ();
            D.35976 = D.35975->break_on_unverified;
            if (D.35976 != 0) goto <D.35977>; else goto unverified;
            <D.35977>:
            raise (5);
            <D.35970>:
            token = MEM[(const guint32 *)ip + 1B];
            cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
            if (cmethod == 0B) goto <D.35978>; else goto <D.35980>;
            <D.35980>:
            D.35981 = mono_loader_get_last_error ();
            if (D.35981 != 0B) goto <D.35978>; else goto <D.35979>;
            <D.35978>:
            D.35982 = mini_get_debug_options ();
            D.35983 = D.35982->break_on_unverified;
            if (D.35983 != 0) goto <D.35984>; else goto load_error;
            <D.35984>:
            raise (5);
            <D.35979>:
            fsig = mono_method_get_signature (cmethod, image, token);
            if (fsig == 0B) goto <D.35985>; else goto <D.35986>;
            <D.35985>:
            D.35987 = mini_get_debug_options ();
            D.35988 = D.35987->break_on_unverified;
            if (D.35988 != 0) goto <D.35989>; else goto load_error;
            <D.35989>:
            raise (5);
            <D.35986>:
            mono_save_token_info (cfg, image, token, cmethod);
            D.32828 = cmethod->klass;
            D.35990 = mono_class_init (D.32828);
            if (D.35990 == 0) goto <D.35991>; else goto <D.35992>;
            <D.35991>:
            D.35993 = mini_get_debug_options ();
            D.35994 = D.35993->break_on_unverified;
            if (D.35994 != 0) goto <D.35995>; else goto <D.35996>;
            <D.35995>:
            raise (5);
            goto <D.35997>;
            <D.35996>:
            D.32828 = cmethod->klass;
            cfg->exception_ptr = D.32828;
            goto load_error;
            <D.35997>:
            <D.35992>:
            context_used = mini_method_check_context_used (cfg, cmethod);
            D.35998 = mono_security_get_mode ();
            if (D.35998 == 2) goto <D.35999>; else goto <D.36000>;
            <D.35999>:
            D.36001 = check_linkdemand (cfg, method, cmethod);
            if (D.36001 != 0) goto <D.36002>; else goto <D.36003>;
            <D.36002>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.36004>; else goto <D.36005>;
            <D.36004>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.36006>; else goto <D.36007>;
            <D.36006>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.36008>; else goto <D.36009>;
            <D.36008>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.36009>:
            goto inline_failure;
            <D.36007>:
            <D.36005>:
            <D.36003>:
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.36010>;
            <D.36010>:
            goto <D.36011>;
            <D.36000>:
            D.36012 = mono_security_get_mode ();
            if (D.36012 == 1) goto <D.36013>; else goto <D.36014>;
            <D.36013>:
            bblock.70 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.70, ip);
            <D.36014>:
            <D.36011>:
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 != 0B) goto <D.36015>; else goto <D.36016>;
            <D.36015>:
            if (cmethod != 0B) goto <D.36017>; else goto <D.36018>;
            <D.36017>:
            D.32828 = cmethod->klass;
            D.30878 = method->klass;
            if (D.32828 != D.30878) goto <D.36019>; else goto <D.36020>;
            <D.36019>:
            D.32828 = cmethod->klass;
            D.33363 = D.32828->generic_class;
            if (D.33363 != 0B) goto <D.36021>; else goto <D.36022>;
            <D.36021>:
            D.36023 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.36023 != 0) goto <D.36024>; else goto <D.36025>;
            <D.36024>:
            D.32828 = cmethod->klass;
            D.36026 = mono_class_needs_cctor_run (D.32828, method);
            if (D.36026 != 0) goto <D.36027>; else goto <D.36028>;
            <D.36027>:
            D.32828 = cmethod->klass;
            emit_generic_class_init (cfg, D.32828);
            D.32828 = cmethod->klass;
            if (D.32828 == 0B) goto <D.36029>; else goto <D.36031>;
            <D.36031>:
            D.32828 = cmethod->klass;
            D.33375 = D.32828->exception_type;
            if (D.33375 != 0) goto <D.36029>; else goto <D.36030>;
            <D.36029>:
            D.32828 = cmethod->klass;
            cfg->exception_ptr = D.32828;
            D.36032 = mini_get_debug_options ();
            D.36033 = D.36032->break_on_unverified;
            if (D.36033 != 0) goto <D.36034>; else goto load_error;
            <D.36034>:
            raise (5);
            <D.36030>:
            <D.36028>:
            <D.36025>:
            <D.36022>:
            <D.36020>:
            <D.36018>:
            <D.36016>:
            D.32828 = cmethod->klass;
            D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
            D.32830 = D.32829 & 8;
            if (D.32830 != 0) goto <D.36035>; else goto <D.36036>;
            <D.36035>:
            D.32828 = cmethod->klass;
            D.36037 = mono_class_generic_sharing_enabled (D.32828);
            if (D.36037 != 0) goto <D.36038>; else goto <D.36039>;
            <D.36038>:
            D.36040 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.36040 != 0) goto <D.36041>; else goto <D.36042>;
            <D.36041>:
            D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.33571 = D.32948 & 4096;
            if (D.33571 != 0) goto <D.36045>; else goto <D.36043>;
            <D.36045>:
            D.36046 = mono_method_get_context (cmethod);
            D.36047 = D.36046->method_inst;
            if (D.36047 != 0B) goto <D.36048>; else goto <D.36043>;
            <D.36048>:
            D.30966 = cfg->domain;
            D.32828 = cmethod->klass;
            mono_class_vtable (D.30966, D.32828);
            D.32828 = cmethod->klass;
            if (D.32828 == 0B) goto <D.36049>; else goto <D.36051>;
            <D.36051>:
            D.32828 = cmethod->klass;
            D.33375 = D.32828->exception_type;
            if (D.33375 != 0) goto <D.36049>; else goto <D.36050>;
            <D.36049>:
            D.32828 = cmethod->klass;
            cfg->exception_ptr = D.32828;
            D.36052 = mini_get_debug_options ();
            D.36053 = D.36052->break_on_unverified;
            if (D.36053 != 0) goto <D.36054>; else goto load_error;
            <D.36054>:
            raise (5);
            <D.36050>:
            vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 8);
            goto <D.36044>;
            <D.36043>:
            if (context_used != 0) goto <D.36055>; else goto <D.36056>;
            <D.36055>:
            D.32828 = cmethod->klass;
            vtable_arg = emit_get_rgctx_klass (cfg, context_used, D.32828, 2);
            goto <D.36057>;
            <D.36056>:
            {
              struct MonoVTable * vtable;

              D.30966 = cfg->domain;
              D.32828 = cmethod->klass;
              vtable = mono_class_vtable (D.30966, D.32828);
              D.32828 = cmethod->klass;
              if (D.32828 == 0B) goto <D.36058>; else goto <D.36060>;
              <D.36060>:
              D.32828 = cmethod->klass;
              D.33375 = D.32828->exception_type;
              if (D.33375 != 0) goto <D.36058>; else goto <D.36059>;
              <D.36058>:
              D.32828 = cmethod->klass;
              cfg->exception_ptr = D.32828;
              D.36061 = mini_get_debug_options ();
              D.36062 = D.36061->break_on_unverified;
              if (D.36062 != 0) goto <D.36063>; else goto load_error;
              <D.36063>:
              raise (5);
              <D.36059>:
              D.30941 = cfg->mempool;
              vtable_arg = mono_mempool_alloc (D.30941, 80);
              vtable_arg->data.op[1].const_val = 0;
              D.36064 = vtable_arg->data.op[1].const_val;
              vtable_arg->data.op[0].const_val = D.36064;
              vtable_arg->prev = 0B;
              D.36065 = vtable_arg->prev;
              vtable_arg->next = D.36065;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.36067>; else goto <D.36068>;
              <D.36067>:
              iftmp.166 = 734;
              goto <D.36069>;
              <D.36068>:
              iftmp.166 = 363;
              <D.36069>:
              vtable_arg->opcode = iftmp.166;
              vtable_arg->flags = 0;
              vtable_arg->type = 0;
              vtable_arg->dreg = -1;
              vtable_arg->sreg3 = -1;
              D.36070 = vtable_arg->sreg3;
              vtable_arg->sreg2 = D.36070;
              D.36071 = vtable_arg->sreg2;
              vtable_arg->sreg1 = D.36071;
              D.31162 = cfg->ip;
              vtable_arg->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.36072>; else goto <D.36073>;
              <D.36072>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.36074 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.36074;
                group->prev = 0B;
                D.36075 = group->prev;
                group->next = D.36075;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.36076 = group->sreg3;
                group->sreg2 = D.36076;
                D.36077 = group->sreg2;
                group->sreg1 = D.36077;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.31337 = D.31336 & 274877906944;
                if (D.31337 != 0) goto <D.36079>; else goto <D.36080>;
                <D.36079>:
                iftmp.167 = vtable->klass;
                goto <D.36081>;
                <D.36080>:
                iftmp.167 = vtable;
                <D.36081>:
                group->data.op[0].src = iftmp.167;
                group->data.op[1].src = 14B;
                D.36082 = got_loc->dreg;
                vtable_arg->sreg1 = D.36082;
                vtable_arg->data.op[1].p = group;
              }
              goto <D.36083>;
              <D.36073>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.36085>; else goto <D.36086>;
              <D.36085>:
              iftmp.168 = vtable->klass;
              goto <D.36087>;
              <D.36086>:
              iftmp.168 = vtable;
              <D.36087>:
              vtable_arg->data.op[0].p = iftmp.168;
              vtable_arg->data.op[1].src = 14B;
              <D.36083>:
              vtable_arg->type = 3;
              D.36088 = alloc_dreg (cfg, 3);
              D.36089 = (int) D.36088;
              vtable_arg->dreg = D.36089;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.36090>; else goto <D.36091>;
              <D.36090>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = vtable_arg;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              vtable_arg->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = vtable_arg;
              goto <D.36092>;
              <D.36091>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = vtable_arg;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.36092>:
            }
            <D.36057>:
            <D.36044>:
            <D.36042>:
            <D.36039>:
            <D.36036>:
            D.36093 = fsig->param_count;
            n = (int) D.36093;
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.32978 = (long int) n;
            if (D.31731 < D.32978) goto <D.36094>; else goto <D.36095>;
            <D.36094>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.36096>; else goto <D.36097>;
            <D.36096>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.36098>; else goto <D.36099>;
            <D.36098>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.36099>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.36097>:
            D.36100 = mini_get_debug_options ();
            D.36101 = D.36100->break_on_unverified;
            if (D.36101 != 0) goto <D.36102>; else goto unverified;
            <D.36102>:
            raise (5);
            <D.36095>:
            bblock.70 = bblock;
            D.35895 = BIT_FIELD_REF <*bblock.70, 64, 1472>;
            D.35896 = D.35895 & 65536;
            if (D.35896 != 0) goto <D.36106>; else goto <D.36107>;
            <D.36106>:
            D.32828 = cmethod->klass;
            D.33004 = D.32828->image;
            D.33005 = mono_defaults.corlib;
            if (D.33004 == D.33005) goto <D.36108>; else goto <D.36109>;
            <D.36108>:
            D.32828 = cmethod->klass;
            D.36110 = is_exception_class (D.32828);
            if (D.36110 != 0) goto <D.36111>; else goto <D.36112>;
            <D.36111>:
            if (n <= 2) goto <D.36113>; else goto <D.36114>;
            <D.36113>:
            if (n <= 0) goto <D.36105>; else goto <D.36115>;
            <D.36115>:
            D.36116 = fsig->params[0];
            D.36117 = BIT_FIELD_REF <*D.36116, 64, 64>;
            D.36118 = D.36117 & 1090453504;
            if (D.36118 == 917504) goto <D.36105>; else goto <D.36104>;
            <D.36105>:
            if (n <= 1) goto <D.36103>; else goto <D.36119>;
            <D.36119>:
            D.36120 = fsig->params[1];
            D.36121 = BIT_FIELD_REF <*D.36120, 64, 64>;
            D.36122 = D.36121 & 1090453504;
            if (D.36122 == 917504) goto <D.36103>; else goto <D.36104>;
            <D.36103>:
            {
              struct MonoInst * iargs[3];

              try
                {
                  D.36123 = vtable_arg != 0B;
                  D.36124 = (long int) D.36123;
                  D.36125 = __builtin_expect (D.36124, 0);
                  if (D.36125 != 0) goto <D.36126>; else goto <D.36127>;
                  <D.36126>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9300, "!vtable_arg");
                  <D.36127>:
                  D.31883 = (long unsigned int) n;
                  D.31884 = D.31883 * 8;
                  D.32988 = -D.31884;
                  sp = sp + D.32988;
                  D.30941 = cfg->mempool;
                  D.36128 = mono_mempool_alloc (D.30941, 80);
                  iargs[0] = D.36128;
                  D.36129 = iargs[0];
                  D.36129 = iargs[0];
                  D.36129->data.op[1].const_val = 0;
                  D.36130 = D.36129->data.op[1].const_val;
                  D.36129->data.op[0].const_val = D.36130;
                  D.36129 = iargs[0];
                  D.36129 = iargs[0];
                  D.36129->prev = 0B;
                  D.36131 = D.36129->prev;
                  D.36129->next = D.36131;
                  D.36129 = iargs[0];
                  D.36129->opcode = 362;
                  D.36129 = iargs[0];
                  D.36129->flags = 0;
                  D.36129 = iargs[0];
                  D.36129->type = 0;
                  D.36129 = iargs[0];
                  D.36129->dreg = -1;
                  D.36129 = iargs[0];
                  D.36129 = iargs[0];
                  D.36129 = iargs[0];
                  D.36129->sreg3 = -1;
                  D.36132 = D.36129->sreg3;
                  D.36129->sreg2 = D.36132;
                  D.36133 = D.36129->sreg2;
                  D.36129->sreg1 = D.36133;
                  D.36129 = iargs[0];
                  D.31162 = cfg->ip;
                  D.36129->cil_code = D.31162;
                  D.36129 = iargs[0];
                  D.32828 = cmethod->klass;
                  D.36134 = D.32828->type_token;
                  D.36135 = (long int) D.36134;
                  D.36129->data.op[0].const_val = D.36135;
                  D.36129 = iargs[0];
                  D.36129->type = 1;
                  D.36129 = iargs[0];
                  D.36136 = alloc_dreg (cfg, 1);
                  D.36137 = (int) D.36136;
                  D.36129->dreg = D.36137;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.36138>; else goto <D.36139>;
                  <D.36138>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.36129 = iargs[0];
                  D.31191->next = D.36129;
                  D.36129 = iargs[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.36129->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.36129 = iargs[0];
                  bblock.113->last_ins = D.36129;
                  goto <D.36140>;
                  <D.36139>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.36129 = iargs[0];
                  bblock.113->last_ins = D.36129;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.36140>:
                  switch (n) <default: <D.28265>, case 0: <D.28261>, case 1: <D.28263>, case 2: <D.28264>>
                  <D.28261>:
                  sp.169 = sp;
                  sp = sp.169 + 8;
                  D.36142 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_0, &iargs);
                  *sp.169 = D.36142;
                  goto <D.28262>;
                  <D.28263>:
                  D.31957 = *sp;
                  iargs[1] = D.31957;
                  sp.170 = sp;
                  sp = sp.170 + 8;
                  D.36144 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_1, &iargs);
                  *sp.170 = D.36144;
                  goto <D.28262>;
                  <D.28264>:
                  D.31957 = *sp;
                  iargs[1] = D.31957;
                  D.36145 = MEM[(struct MonoInst * *)sp + 8B];
                  iargs[2] = D.36145;
                  sp.171 = sp;
                  sp = sp.171 + 8;
                  D.36147 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_2, &iargs);
                  *sp.171 = D.36147;
                  goto <D.28262>;
                  <D.28265>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9319);
                  <D.28262>:
                  ip = ip + 5;
                  inline_costs = inline_costs + 5;
                  goto <D.27857>;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.36104>:
            <D.36114>:
            <D.36112>:
            <D.36109>:
            <D.36107>:
            goto <D.28267>;
            <D.28266>:
            sp = sp + 18446744073709551608;
            D.33089 = sp + 8;
            D.31957 = *sp;
            *D.33089 = D.31957;
            <D.28267>:
            n.172 = n;
            n = n.172 + -1;
            if (n.172 != 0) goto <D.28266>; else goto <D.28268>;
            <D.28268>:
            this_ins.type = 6;
            *sp = &this_ins;
            D.36149 = check_call_signature (cfg, fsig, sp);
            if (D.36149 != 0) goto <D.36150>; else goto <D.36151>;
            <D.36150>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.36152>; else goto <D.36153>;
            <D.36152>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.36154>; else goto <D.36155>;
            <D.36154>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.36155>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.36153>:
            D.36156 = mini_get_debug_options ();
            D.36157 = D.36156->break_on_unverified;
            if (D.36157 != 0) goto <D.36158>; else goto unverified;
            <D.36158>:
            raise (5);
            <D.36151>:
            iargs[0] = 0B;
            D.32828 = cmethod->klass;
            D.36159 = mini_class_is_system_array (D.32828);
            if (D.36159 != 0) goto <D.36160>; else goto <D.36161>;
            <D.36160>:
            D.36123 = vtable_arg != 0B;
            D.36124 = (long int) D.36123;
            D.36125 = __builtin_expect (D.36124, 0);
            if (D.36125 != 0) goto <D.36162>; else goto <D.36163>;
            <D.36162>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9342, "!vtable_arg");
            <D.36163>:
            D.36164 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            *sp = D.36164;
            D.36093 = fsig->param_count;
            if (D.36093 == 1) goto <D.36165>; else goto <D.36166>;
            <D.36165>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_1, sp);
            goto <D.36167>;
            <D.36166>:
            D.36093 = fsig->param_count;
            if (D.36093 == 2) goto <D.36168>; else goto <D.36169>;
            <D.36168>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_2, sp);
            goto <D.36170>;
            <D.36169>:
            D.36093 = fsig->param_count;
            if (D.36093 == 3) goto <D.36171>; else goto <D.36172>;
            <D.36171>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_3, sp);
            goto <D.36173>;
            <D.36172>:
            D.36093 = fsig->param_count;
            if (D.36093 == 4) goto <D.36174>; else goto <D.36175>;
            <D.36174>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_4, sp);
            goto <D.36176>;
            <D.36175>:
            D.36093 = fsig->param_count;
            D.36177 = (int) D.36093;
            alloc = handle_array_new (cfg, D.36177, sp, ip);
            <D.36176>:
            <D.36173>:
            <D.36170>:
            <D.36167>:
            goto <D.36178>;
            <D.36161>:
            D.32948 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.32949 = D.32948 & 128;
            if (D.32949 != 0) goto <D.36179>; else goto <D.36180>;
            <D.36179>:
            D.36181 = context_used != 0;
            D.36182 = (long int) D.36181;
            D.36183 = __builtin_expect (D.36182, 0);
            if (D.36183 != 0) goto <D.36184>; else goto <D.36185>;
            <D.36184>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9359, "!context_used");
            <D.36185>:
            D.36123 = vtable_arg != 0B;
            D.36124 = (long int) D.36123;
            D.36125 = __builtin_expect (D.36124, 0);
            if (D.36125 != 0) goto <D.36186>; else goto <D.36187>;
            <D.36186>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9360, "!vtable_arg");
            <D.36187>:
            D.30941 = cfg->mempool;
            D.36188 = mono_mempool_alloc (D.30941, 80);
            *sp = D.36188;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 363;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.31957->data.op[0].p = 0B;
            D.31957 = *sp;
            D.31957->type = 3;
            D.31957 = *sp;
            D.36189 = alloc_dreg (cfg, 3);
            D.36190 = (int) D.36189;
            D.31957->dreg = D.36190;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36191>; else goto <D.36192>;
            <D.36191>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.36193>;
            <D.36192>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36193>:
            alloc = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, 0B, 0B, 0B);
            goto <D.36194>;
            <D.36180>:
            {
              struct MonoInst * callvirt_this_arg;

              callvirt_this_arg = 0B;
              D.32828 = cmethod->klass;
              D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
              D.32830 = D.32829 & 8;
              if (D.32830 != 0) goto <D.36195>; else goto <D.36196>;
              <D.36195>:
              D.32828 = cmethod->klass;
              D.36197 = &D.32828->byval_arg;
              D.36198 = mono_compile_create_var (cfg, D.36197, 329);
              iargs[0] = D.36198;
              D.36199 = iargs[0];
              D.36200 = D.36199->dreg;
              D.32828 = cmethod->klass;
              D.36197 = &D.32828->byval_arg;
              emit_init_rvar (cfg, D.36200, D.36197);
              D.30941 = cfg->mempool;
              D.36201 = mono_mempool_alloc (D.30941, 80);
              *sp = D.36201;
              D.31957 = *sp;
              D.31957 = *sp;
              D.31957->data.op[1].const_val = 0;
              D.33682 = D.31957->data.op[1].const_val;
              D.31957->data.op[0].const_val = D.33682;
              D.31957 = *sp;
              D.31957 = *sp;
              D.31957->prev = 0B;
              D.33683 = D.31957->prev;
              D.31957->next = D.33683;
              D.31957 = *sp;
              D.31957->opcode = 314;
              D.31957 = *sp;
              D.31957->flags = 0;
              D.31957 = *sp;
              D.31957->type = 0;
              D.31957 = *sp;
              D.31957->dreg = -1;
              D.31957 = *sp;
              D.31957 = *sp;
              D.31957 = *sp;
              D.31957->sreg3 = -1;
              D.33684 = D.31957->sreg3;
              D.31957->sreg2 = D.33684;
              D.33685 = D.31957->sreg2;
              D.31957->sreg1 = D.33685;
              D.31957 = *sp;
              D.31162 = cfg->ip;
              D.31957->cil_code = D.31162;
              D.31957 = *sp;
              D.31695 = cfg->varinfo;
              D.36199 = iargs[0];
              D.36202 = D.36199->data.op[0].const_val;
              D.36203 = (long unsigned int) D.36202;
              D.36204 = D.36203 * 8;
              D.36205 = D.31695 + D.36204;
              D.36206 = *D.36205;
              D.31957->data.op[0].p = D.36206;
              D.31695 = cfg->varinfo;
              D.36199 = iargs[0];
              D.36202 = D.36199->data.op[0].const_val;
              D.36203 = (long unsigned int) D.36202;
              D.36204 = D.36203 * 8;
              D.36205 = D.31695 + D.36204;
              D.36206 = *D.36205;
              D.31695 = cfg->varinfo;
              D.36199 = iargs[0];
              D.36202 = D.36199->data.op[0].const_val;
              D.36203 = (long unsigned int) D.36202;
              D.36204 = D.36203 * 8;
              D.36205 = D.31695 + D.36204;
              D.36206 = *D.36205;
              D.36207 = D.36206->flags;
              D.36208 = D.36207 | 16;
              D.36206->flags = D.36208;
              D.31957 = *sp;
              D.31957->type = 5;
              D.31957 = *sp;
              D.31695 = cfg->varinfo;
              D.36199 = iargs[0];
              D.36202 = D.36199->data.op[0].const_val;
              D.36203 = (long unsigned int) D.36202;
              D.36204 = D.36203 * 8;
              D.36205 = D.31695 + D.36204;
              D.36206 = *D.36205;
              D.36209 = D.36206->klass;
              D.31957->klass = D.36209;
              D.31957 = *sp;
              D.36210 = alloc_dreg (cfg, 5);
              D.36211 = (int) D.36210;
              D.31957->dreg = D.36211;
              cfg->has_indirection = 1;
              D.31089 = cfg->gsharedvt;
              D.32043 = D.31089 != 0;
              D.32044 = (long int) D.32043;
              D.32045 = __builtin_expect (D.32044, 0);
              if (D.32045 != 0) goto <D.36212>; else goto <D.36213>;
              <D.36212>:
              D.31695 = cfg->varinfo;
              D.36199 = iargs[0];
              D.36202 = D.36199->data.op[0].const_val;
              D.36203 = (long unsigned int) D.36202;
              D.36204 = D.36203 * 8;
              D.36205 = D.31695 + D.36204;
              D.36206 = *D.36205;
              D.36214 = D.36206->data.op[1].vtype;
              D.36215 = mini_is_gsharedvt_variable_type (cfg, D.36214);
              if (D.36215 != 0) goto <D.36216>; else goto <D.36217>;
              <D.36216>:
              handle_gsharedvt_ldaddr (cfg);
              <D.36217>:
              <D.36213>:
              if (0 != 0) goto <D.36218>; else goto <D.36219>;
              <D.36218>:
              {
                struct MonoInst * var1;
                struct MonoInst * var2;

                D.31695 = cfg->varinfo;
                D.36199 = iargs[0];
                D.36202 = D.36199->data.op[0].const_val;
                D.36203 = (long unsigned int) D.36202;
                D.36204 = D.36203 * 8;
                D.36205 = D.31695 + D.36204;
                D.36206 = *D.36205;
                D.36221 = D.36206->dreg;
                D.36222 = D.36221 + 1;
                D.36223 = (unsigned int) D.36222;
                D.32058 = cfg->vreg_to_inst_len;
                if (D.36223 < D.32058) goto <D.36224>; else goto <D.36225>;
                <D.36224>:
                D.32061 = cfg->vreg_to_inst;
                D.31695 = cfg->varinfo;
                D.36199 = iargs[0];
                D.36202 = D.36199->data.op[0].const_val;
                D.36203 = (long unsigned int) D.36202;
                D.36204 = D.36203 * 8;
                D.36205 = D.31695 + D.36204;
                D.36206 = *D.36205;
                D.36221 = D.36206->dreg;
                D.36226 = (sizetype) D.36221;
                D.36227 = D.36226 + 1;
                D.36228 = D.36227 * 8;
                D.36229 = D.32061 + D.36228;
                iftmp.173 = *D.36229;
                goto <D.36230>;
                <D.36225>:
                iftmp.173 = 0B;
                <D.36230>:
                var1 = iftmp.173;
                D.31695 = cfg->varinfo;
                D.36199 = iargs[0];
                D.36202 = D.36199->data.op[0].const_val;
                D.36203 = (long unsigned int) D.36202;
                D.36204 = D.36203 * 8;
                D.36205 = D.31695 + D.36204;
                D.36206 = *D.36205;
                D.36221 = D.36206->dreg;
                D.36232 = D.36221 + 2;
                D.36233 = (unsigned int) D.36232;
                D.32058 = cfg->vreg_to_inst_len;
                if (D.36233 < D.32058) goto <D.36234>; else goto <D.36235>;
                <D.36234>:
                D.32061 = cfg->vreg_to_inst;
                D.31695 = cfg->varinfo;
                D.36199 = iargs[0];
                D.36202 = D.36199->data.op[0].const_val;
                D.36203 = (long unsigned int) D.36202;
                D.36204 = D.36203 * 8;
                D.36205 = D.31695 + D.36204;
                D.36206 = *D.36205;
                D.36221 = D.36206->dreg;
                D.36226 = (sizetype) D.36221;
                D.36236 = D.36226 + 2;
                D.36237 = D.36236 * 8;
                D.36238 = D.32061 + D.36237;
                iftmp.174 = *D.36238;
                goto <D.36239>;
                <D.36235>:
                iftmp.174 = 0B;
                <D.36239>:
                var2 = iftmp.174;
                D.36240 = var1 == 0B;
                D.36241 = (long int) D.36240;
                D.36242 = __builtin_expect (D.36241, 0);
                if (D.36242 != 0) goto <D.36243>; else goto <D.36244>;
                <D.36243>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9371, "var1");
                <D.36244>:
                D.36245 = var2 == 0B;
                D.36246 = (long int) D.36245;
                D.36247 = __builtin_expect (D.36246, 0);
                if (D.36247 != 0) goto <D.36248>; else goto <D.36249>;
                <D.36248>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9371, "var2");
                <D.36249>:
                D.36250 = var1->flags;
                D.36251 = D.36250 | 16;
                var1->flags = D.36251;
                D.36252 = var2->flags;
                D.36253 = D.36252 | 16;
                var2->flags = D.36253;
              }
              <D.36219>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.36254>; else goto <D.36255>;
              <D.36254>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31957 = *sp;
              D.31191->next = D.31957;
              D.31957 = *sp;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31957->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.31957 = *sp;
              bblock.113->last_ins = D.31957;
              goto <D.36256>;
              <D.36255>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.31957 = *sp;
              bblock.113->last_ins = D.31957;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.36256>:
              alloc = 0B;
              goto <D.36257>;
              <D.36196>:
              if (context_used != 0) goto <D.36258>; else goto <D.36259>;
              <D.36258>:
              D.32828 = cmethod->klass;
              alloc = handle_alloc (cfg, D.32828, 0, context_used);
              *sp = alloc;
              goto <D.36260>;
              <D.36259>:
              {
                struct MonoVTable * vtable;

                vtable = 0B;
                D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.31337 = D.31336 & 274877906944;
                if (D.31337 == 0) goto <D.36261>; else goto <D.36262>;
                <D.36261>:
                D.30966 = cfg->domain;
                D.32828 = cmethod->klass;
                vtable = mono_class_vtable (D.30966, D.32828);
                <D.36262>:
                D.32828 = cmethod->klass;
                if (D.32828 == 0B) goto <D.36263>; else goto <D.36265>;
                <D.36265>:
                D.32828 = cmethod->klass;
                D.33375 = D.32828->exception_type;
                if (D.33375 != 0) goto <D.36263>; else goto <D.36264>;
                <D.36263>:
                D.32828 = cmethod->klass;
                cfg->exception_ptr = D.32828;
                D.36266 = mini_get_debug_options ();
                D.36267 = D.36266->break_on_unverified;
                if (D.36267 != 0) goto <D.36268>; else goto load_error;
                <D.36268>:
                raise (5);
                <D.36264>:
                D.32828 = cmethod->klass;
                D.36269 = mini_field_access_needs_cctor_run (cfg, method, D.32828, vtable);
                if (D.36269 != 0) goto <D.36270>; else goto <D.36271>;
                <D.36270>:
                D.32828 = cmethod->klass;
                D.36272 = monoeg_g_slist_find (class_inits, D.32828);
                if (D.36272 == 0B) goto <D.36273>; else goto <D.36274>;
                <D.36273>:
                D.32828 = cmethod->klass;
                helper_sig_class_init_trampoline.175 = helper_sig_class_init_trampoline;
                mono_emit_abs_call (cfg, 15, D.32828, helper_sig_class_init_trampoline.175, 0B);
                D.31021 = cfg->verbose_level;
                if (D.31021 > 2) goto <D.36276>; else goto <D.36277>;
                <D.36276>:
                D.32828 = cmethod->klass;
                D.36278 = D.32828->name_space;
                D.32828 = cmethod->klass;
                D.36279 = D.32828->name;
                printf ("class %s.%s needs init call for ctor\n", D.36278, D.36279);
                <D.36277>:
                D.32828 = cmethod->klass;
                class_inits = monoeg_g_slist_prepend (class_inits, D.32828);
                <D.36274>:
                <D.36271>:
                D.32828 = cmethod->klass;
                alloc = handle_alloc (cfg, D.32828, 0, 0);
                *sp = alloc;
              }
              <D.36260>:
              <D.36257>:
              D.31510 = cfg->exception_type;
              if (D.31510 != 0) goto exception_exit; else goto <D.36280>;
              <D.36280>:
              if (alloc != 0B) goto <D.36281>; else goto <D.36282>;
              <D.36281>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.36283 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.36283;
                inst->prev = 0B;
                D.36284 = inst->prev;
                inst->next = D.36284;
                inst->opcode = 799;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.36285 = inst->sreg3;
                inst->sreg2 = D.36285;
                D.36286 = inst->sreg2;
                inst->sreg1 = D.36286;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->dreg = -1;
                D.36287 = alloc->dreg;
                inst->sreg1 = D.36287;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.36288>; else goto <D.36289>;
                <D.36288>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.36290>;
                <D.36289>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.36290>:
              }
              <D.36282>:
              D.32828 = cmethod->klass;
              D.32829 = BIT_FIELD_REF <*D.32828, 64, 256>;
              D.32871 = D.32829 & 4194304;
              if (D.32871 != 0) goto <D.36291>; else goto <D.36292>;
              <D.36291>:
              callvirt_this_arg = *sp;
              <D.36292>:
              if (cmethod != 0B) goto <D.36295>; else goto <D.36293>;
              <D.36295>:
              D.31334 = cfg->opt;
              D.33349 = D.31334 & 2048;
              if (D.33349 != 0) goto <D.36296>; else goto <D.36293>;
              <D.36296>:
              ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp);
              if (ins != 0B) goto <D.36297>; else goto <D.36293>;
              <D.36297>:
              D.36298 = fsig->ret;
              D.36299 = mono_type_is_void (D.36298);
              if (D.36299 == 0) goto <D.36300>; else goto <D.36301>;
              <D.36300>:
              D.36298 = fsig->ret;
              type_to_eval_stack_type (cfg, D.36298, ins);
              *sp = ins;
              sp = sp + 8;
              <D.36301>:
              D.31510 = cfg->exception_type;
              if (D.31510 != 0) goto exception_exit; else goto <D.36302>;
              <D.36302>:
              goto <D.36294>;
              <D.36293>:
              D.31334 = cfg->opt;
              D.33798 = D.31334 & 4;
              if (D.33798 != 0) goto <D.36305>; else goto <D.36303>;
              <D.36305>:
              if (cmethod != 0B) goto <D.36306>; else goto <D.36303>;
              <D.36306>:
              if (context_used == 0) goto <D.36307>; else goto <D.36303>;
              <D.36307>:
              if (vtable_arg == 0B) goto <D.36308>; else goto <D.36303>;
              <D.36308>:
              if (disable_inline == 0) goto <D.36309>; else goto <D.36303>;
              <D.36309>:
              D.36310 = mono_method_check_inlining (cfg, cmethod);
              if (D.36310 != 0) goto <D.36311>; else goto <D.36303>;
              <D.36311>:
              D.32828 = cmethod->klass;
              D.36312 = mono_defaults.exception_class;
              D.36313 = mono_class_is_subclass_of (D.32828, D.36312, 0);
              if (D.36313 == 0) goto <D.36314>; else goto <D.36303>;
              <D.36314>:
              D.36315 = monoeg_g_list_find (dont_inline, cmethod);
              if (D.36315 == 0B) goto <D.36316>; else goto <D.36303>;
              <D.36316>:
              {
                int costs;

                D.31108 = cfg->real_offset;
                costs = inline_method (cfg, cmethod, fsig, sp, ip, D.31108, dont_inline, 0);
                if (costs != 0) goto <D.36317>; else goto <D.36318>;
                <D.36317>:
                D.31108 = cfg->real_offset;
                D.33825 = D.31108 + 5;
                cfg->real_offset = D.33825;
                bblock.113 = cfg->cbb;
                bblock = bblock.113;
                D.36319 = costs + -5;
                inline_costs = D.36319 + inline_costs;
                goto <D.36320>;
                <D.36318>:
                D.30911 = cfg->method;
                if (D.30911 != method) goto <D.36321>; else goto <D.36322>;
                <D.36321>:
                D.30883 = BIT_FIELD_REF <*method, 64, 256>;
                D.30884 = D.30883 & 124;
                if (D.30884 == 0) goto <D.36323>; else goto <D.36324>;
                <D.36323>:
                D.31021 = cfg->verbose_level;
                if (D.31021 > 1) goto <D.36325>; else goto <D.36326>;
                <D.36325>:
                printf ("inline failed: %s\n", "inline failure");
                <D.36326>:
                goto inline_failure;
                <D.36324>:
                <D.36322>:
                D.31089 = cfg->gsharedvt;
                if (D.31089 != 0) goto <D.36327>; else goto <D.36328>;
                <D.36327>:
                D.36329 = mini_is_gsharedvt_signature (cfg, fsig);
                if (D.36329 != 0) goto <D.36330>; else goto <D.36331>;
                <D.36330>:
                D.31089 = cfg->gsharedvt;
                if (D.31089 != 0) goto <D.36332>; else goto <D.36333>;
                <D.36332>:
                D.30878 = method->klass;
                D.32629 = D.30878->name_space;
                D.30878 = method->klass;
                D.32630 = D.30878->name;
                D.32631 = method->name;
                D.32632 = method->signature;
                D.32633 = D.32632->param_count;
                D.32634 = (int) D.32633;
                D.31838 = *ip;
                D.31839 = (int) D.31838;
                D.36334 = mono_opcode_name (D.31839);
                D.36335 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.36334, "method-to-ir.c", 9439);
                cfg->exception_message = D.36335;
                D.31021 = cfg->verbose_level;
                if (D.31021 > 1) goto <D.36336>; else goto <D.36337>;
                <D.36336>:
                D.32639 = cfg->exception_message;
                printf ("%s\n", D.32639);
                <D.36337>:
                mono_cfg_set_exception (cfg, 11);
                goto exception_exit;
                <D.36333>:
                <D.36331>:
                <D.36328>:
                mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, callvirt_this_arg, 0B, 0B);
                <D.36320>:
              }
              goto <D.36304>;
              <D.36303>:
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.36340>; else goto <D.36338>;
              <D.36340>:
              D.36341 = mini_is_gsharedvt_signature (cfg, fsig);
              if (D.36341 != 0) goto <D.36342>; else goto <D.36338>;
              <D.36342>:
              {
                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.36339>;
              <D.36338>:
              if (context_used != 0) goto <D.36346>; else goto <D.36343>;
              <D.36346>:
              D.36347 = mono_method_is_generic_sharable (cmethod, 1);
              if (D.36347 == 0) goto <D.36344>; else goto <D.36348>;
              <D.36348>:
              D.32828 = cmethod->klass;
              D.36349 = mono_class_generic_sharing_enabled (D.32828);
              if (D.36349 == 0) goto <D.36344>; else goto <D.36343>;
              <D.36344>:
              {
                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.36345>;
              <D.36343>:
              D.30911 = cfg->method;
              if (D.30911 != method) goto <D.36350>; else goto <D.36351>;
              <D.36350>:
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 == 0) goto <D.36352>; else goto <D.36353>;
              <D.36352>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.36354>; else goto <D.36355>;
              <D.36354>:
              printf ("inline failed: %s\n", "ctor call");
              <D.36355>:
              goto inline_failure;
              <D.36353>:
              <D.36351>:
              ins = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, callvirt_this_arg, 0B, vtable_arg);
              <D.36345>:
              <D.36339>:
              <D.36304>:
              <D.36294>:
            }
            <D.36194>:
            <D.36178>:
            if (alloc == 0B) goto <D.36356>; else goto <D.36357>;
            <D.36356>:
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 424;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.31695 = cfg->varinfo;
            D.36199 = iargs[0];
            D.36202 = D.36199->data.op[0].const_val;
            D.36203 = (long unsigned int) D.36202;
            D.36204 = D.36203 * 8;
            D.36205 = D.31695 + D.36204;
            D.36206 = *D.36205;
            D.36214 = D.36206->data.op[1].vtype;
            D.36358 = mono_type_to_regmove (cfg, D.36214);
            D.36359 = (short unsigned int) D.36358;
            ins->opcode = D.36359;
            D.31695 = cfg->varinfo;
            D.36199 = iargs[0];
            D.36202 = D.36199->data.op[0].const_val;
            D.36203 = (long unsigned int) D.36202;
            D.36204 = D.36203 * 8;
            D.36205 = D.31695 + D.36204;
            D.36206 = *D.36205;
            D.36214 = D.36206->data.op[1].vtype;
            type_to_eval_stack_type (cfg, D.36214, ins);
            D.31695 = cfg->varinfo;
            D.36199 = iargs[0];
            D.36202 = D.36199->data.op[0].const_val;
            D.36203 = (long unsigned int) D.36202;
            D.36204 = D.36203 * 8;
            D.36205 = D.31695 + D.36204;
            D.36206 = *D.36205;
            D.36209 = D.36206->klass;
            ins->klass = D.36209;
            D.31695 = cfg->varinfo;
            D.36199 = iargs[0];
            D.36202 = D.36199->data.op[0].const_val;
            D.36203 = (long unsigned int) D.36202;
            D.36204 = D.36203 * 8;
            D.36205 = D.31695 + D.36204;
            D.36206 = *D.36205;
            D.36221 = D.36206->dreg;
            ins->sreg1 = D.36221;
            D.31705 = ins->type;
            D.31706 = (<unnamed type>) D.31705;
            D.36360 = alloc_dreg (cfg, D.31706);
            D.36361 = (int) D.36360;
            ins->dreg = D.36361;
            D.31709 = ins->opcode;
            if (D.31709 == 427) goto <D.36362>; else goto <D.36363>;
            <D.36362>:
            D.31695 = cfg->varinfo;
            D.36199 = iargs[0];
            D.36202 = D.36199->data.op[0].const_val;
            D.36203 = (long unsigned int) D.36202;
            D.36204 = D.36203 * 8;
            D.36205 = D.31695 + D.36204;
            D.36206 = *D.36205;
            D.36214 = D.36206->data.op[1].vtype;
            D.36364 = mono_class_from_mono_type (D.36214);
            ins->klass = D.36364;
            <D.36363>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36365>; else goto <D.36366>;
            <D.36365>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.36367>;
            <D.36366>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36367>:
            D.36368 = ins->klass;
            D.36369 = &D.36368->byval_arg;
            type_to_eval_stack_type (cfg, D.36369, ins);
            sp.176 = sp;
            sp = sp.176 + 8;
            *sp.176 = ins;
            goto <D.36371>;
            <D.36357>:
            sp.177 = sp;
            sp = sp.177 + 8;
            *sp.177 = alloc;
            <D.36371>:
            ip = ip + 5;
            inline_costs = inline_costs + 5;
            goto <D.27857>;
          }
        finally
          {
            iargs = {CLOBBER};
            this_ins = {CLOBBER};
          }
      }
      <D.28277>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.36373>; else goto <D.36374>;
      <D.36373>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36375>; else goto <D.36376>;
      <D.36375>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36377>; else goto <D.36378>;
      <D.36377>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36378>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36376>:
      D.36379 = mini_get_debug_options ();
      D.36380 = D.36379->break_on_unverified;
      if (D.36380 != 0) goto <D.36381>; else goto unverified;
      <D.36381>:
      raise (5);
      <D.36374>:
      sp = sp + 18446744073709551608;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.36382>; else goto <D.36383>;
      <D.36382>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36384>; else goto <D.36385>;
      <D.36384>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36386>; else goto <D.36387>;
      <D.36386>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36387>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36385>:
      D.36388 = mini_get_debug_options ();
      D.36389 = D.36388->break_on_unverified;
      if (D.36389 != 0) goto <D.36390>; else goto unverified;
      <D.36390>:
      raise (5);
      <D.36383>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.178 = mini_get_class (method, token, generic_context);
      klass = klass.178;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.36392>; else goto <D.36394>;
      <D.36394>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.36392>; else goto <D.36393>;
      <D.36392>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.36395 = mini_get_debug_options ();
      D.36396 = D.36395->break_on_unverified;
      if (D.36396 != 0) goto <D.36397>; else goto load_error;
      <D.36397>:
      raise (5);
      <D.36393>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 != 6) goto <D.36398>; else goto <D.36399>;
      <D.36398>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36400>; else goto <D.36401>;
      <D.36400>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36402>; else goto <D.36403>;
      <D.36402>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36403>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36401>:
      D.36404 = mini_get_debug_options ();
      D.36405 = D.36404->break_on_unverified;
      if (D.36405 != 0) goto <D.36406>; else goto unverified;
      <D.36406>:
      raise (5);
      <D.36399>:
      klass.157 = klass;
      context_used = mini_class_check_context_used (cfg, klass.157);
      if (context_used == 0) goto <D.36409>; else goto <D.36407>;
      <D.36409>:
      klass.157 = klass;
      D.36410 = mini_class_has_reference_variant_generic_argument (cfg, klass.157, context_used);
      if (D.36410 != 0) goto <D.36411>; else goto <D.36407>;
      <D.36411>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * args[3];

        try
          {
            mono_castclass = mono_marshal_get_castclass_with_cache ();
            D.31957 = *sp;
            args[0] = D.31957;
            D.30941 = cfg->mempool;
            D.36412 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.36412;
            D.36413 = args[1];
            D.36413 = args[1];
            D.36413->data.op[1].const_val = 0;
            D.36414 = D.36413->data.op[1].const_val;
            D.36413->data.op[0].const_val = D.36414;
            D.36413 = args[1];
            D.36413 = args[1];
            D.36413->prev = 0B;
            D.36415 = D.36413->prev;
            D.36413->next = D.36415;
            D.36413 = args[1];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36417>; else goto <D.36418>;
            <D.36417>:
            iftmp.179 = 734;
            goto <D.36419>;
            <D.36418>:
            iftmp.179 = 363;
            <D.36419>:
            D.36413->opcode = iftmp.179;
            D.36413 = args[1];
            D.36413->flags = 0;
            D.36413 = args[1];
            D.36413->type = 0;
            D.36413 = args[1];
            D.36413->dreg = -1;
            D.36413 = args[1];
            D.36413 = args[1];
            D.36413 = args[1];
            D.36413->sreg3 = -1;
            D.36420 = D.36413->sreg3;
            D.36413->sreg2 = D.36420;
            D.36421 = D.36413->sreg2;
            D.36413->sreg1 = D.36421;
            D.36413 = args[1];
            D.31162 = cfg->ip;
            D.36413->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36422>; else goto <D.36423>;
            <D.36422>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36424 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36424;
              group->prev = 0B;
              D.36425 = group->prev;
              group->next = D.36425;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36426 = group->sreg3;
              group->sreg2 = D.36426;
              D.36427 = group->sreg2;
              group->sreg1 = D.36427;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              klass.157 = klass;
              group->data.op[0].src = klass.157;
              group->data.op[1].src = 11B;
              D.36413 = args[1];
              D.36428 = got_loc->dreg;
              D.36413->sreg1 = D.36428;
              D.36413 = args[1];
              D.36413->data.op[1].p = group;
            }
            goto <D.36429>;
            <D.36423>:
            D.36413 = args[1];
            klass.157 = klass;
            D.36413->data.op[0].p = klass.157;
            D.36413 = args[1];
            D.36413->data.op[1].src = 11B;
            <D.36429>:
            D.36413 = args[1];
            D.36413->type = 3;
            D.36413 = args[1];
            D.36430 = alloc_dreg (cfg, 3);
            D.36431 = (int) D.36430;
            D.36413->dreg = D.36431;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36432>; else goto <D.36433>;
            <D.36432>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36413 = args[1];
            D.31191->next = D.36413;
            D.36413 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36413->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36413 = args[1];
            bblock.113->last_ins = D.36413;
            goto <D.36434>;
            <D.36433>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36413 = args[1];
            bblock.113->last_ins = D.36413;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36434>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36435>; else goto <D.36436>;
            <D.36435>:
            D.30941 = cfg->mempool;
            D.36437 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36437;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->data.op[1].const_val = 0;
            D.36439 = D.36438->data.op[1].const_val;
            D.36438->data.op[0].const_val = D.36439;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->prev = 0B;
            D.36440 = D.36438->prev;
            D.36438->next = D.36440;
            D.36438 = args[2];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36442>; else goto <D.36443>;
            <D.36442>:
            iftmp.180 = 734;
            goto <D.36444>;
            <D.36443>:
            iftmp.180 = 363;
            <D.36444>:
            D.36438->opcode = iftmp.180;
            D.36438 = args[2];
            D.36438->flags = 0;
            D.36438 = args[2];
            D.36438->type = 0;
            D.36438 = args[2];
            D.36438->dreg = -1;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->sreg3 = -1;
            D.36445 = D.36438->sreg3;
            D.36438->sreg2 = D.36445;
            D.36446 = D.36438->sreg2;
            D.36438->sreg1 = D.36446;
            D.36438 = args[2];
            D.31162 = cfg->ip;
            D.36438->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36447>; else goto <D.36448>;
            <D.36447>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36449 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36449;
              group->prev = 0B;
              D.36450 = group->prev;
              group->next = D.36450;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36451 = group->sreg3;
              group->sreg2 = D.36451;
              D.36452 = group->sreg2;
              group->sreg1 = D.36452;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 43B;
              D.36438 = args[2];
              D.36453 = got_loc->dreg;
              D.36438->sreg1 = D.36453;
              D.36438 = args[2];
              D.36438->data.op[1].p = group;
            }
            goto <D.36454>;
            <D.36448>:
            D.36438 = args[2];
            D.36438->data.op[0].p = 0B;
            D.36438 = args[2];
            D.36438->data.op[1].src = 43B;
            <D.36454>:
            D.36438 = args[2];
            D.36438->type = 3;
            D.36438 = args[2];
            D.36455 = alloc_dreg (cfg, 3);
            D.36456 = (int) D.36455;
            D.36438->dreg = D.36456;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36457>; else goto <D.36458>;
            <D.36457>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36438 = args[2];
            D.31191->next = D.36438;
            D.36438 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36438->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36438 = args[2];
            bblock.113->last_ins = D.36438;
            goto <D.36459>;
            <D.36458>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36438 = args[2];
            bblock.113->last_ins = D.36438;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36459>:
            goto <D.36460>;
            <D.36436>:
            D.30941 = cfg->mempool;
            D.36461 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36461;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->data.op[1].const_val = 0;
            D.36439 = D.36438->data.op[1].const_val;
            D.36438->data.op[0].const_val = D.36439;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->prev = 0B;
            D.36440 = D.36438->prev;
            D.36438->next = D.36440;
            D.36438 = args[2];
            D.36438->opcode = 363;
            D.36438 = args[2];
            D.36438->flags = 0;
            D.36438 = args[2];
            D.36438->type = 0;
            D.36438 = args[2];
            D.36438->dreg = -1;
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438 = args[2];
            D.36438->sreg3 = -1;
            D.36445 = D.36438->sreg3;
            D.36438->sreg2 = D.36445;
            D.36446 = D.36438->sreg2;
            D.36438->sreg1 = D.36446;
            D.36438 = args[2];
            D.31162 = cfg->ip;
            D.36438->cil_code = D.31162;
            D.36438 = args[2];
            D.30966 = cfg->domain;
            D.36462 = mono_domain_alloc0 (D.30966, 8);
            D.36438->data.op[0].p = D.36462;
            D.36438 = args[2];
            D.36438->type = 3;
            D.36438 = args[2];
            D.36463 = alloc_dreg (cfg, 3);
            D.36464 = (int) D.36463;
            D.36438->dreg = D.36464;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36465>; else goto <D.36466>;
            <D.36465>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36438 = args[2];
            D.31191->next = D.36438;
            D.36438 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36438->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36438 = args[2];
            bblock.113->last_ins = D.36438;
            goto <D.36467>;
            <D.36466>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36438 = args[2];
            bblock.113->last_ins = D.36438;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36467>:
            <D.36460>:
            klass.157 = klass;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            save_cast_details (cfg, klass.157, D.32139, 1, &bblock);
            sp.181 = sp;
            sp = sp.181 + 8;
            D.36469 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
            *sp.181 = D.36469;
            reset_cast_details (cfg);
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.36408>;
      <D.36407>:
      if (context_used == 0) goto <D.36473>; else goto <D.36470>;
      <D.36473>:
      klass.157 = klass;
      D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
      D.36475 = D.36474 & 4194304;
      if (D.36475 != 0) goto <D.36471>; else goto <D.36476>;
      <D.36476>:
      klass.157 = klass;
      D.36477 = klass.157->flags;
      D.36478 = D.36477 & 32;
      if (D.36478 != 0) goto <D.36471>; else goto <D.36470>;
      <D.36471>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.157 = klass;
            mono_castclass = mono_marshal_get_castclass (klass.157);
            D.31957 = *sp;
            iargs[0] = D.31957;
            klass.157 = klass;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            save_cast_details (cfg, klass.157, D.32139, 1, &bblock);
            D.36479 = mono_method_signature (mono_castclass);
            D.31108 = cfg->real_offset;
            costs = inline_method (cfg, mono_castclass, D.36479, &iargs, ip, D.31108, dont_inline, 1);
            reset_cast_details (cfg);
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.36480>;
            <D.36480>:
            D.36481 = costs <= 0;
            D.36482 = (long int) D.36481;
            D.36483 = __builtin_expect (D.36482, 0);
            if (D.36483 != 0) goto <D.36484>; else goto <D.36485>;
            <D.36484>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9524, "costs > 0");
            <D.36485>:
            ip = ip + 5;
            D.31108 = cfg->real_offset;
            D.33825 = D.31108 + 5;
            cfg->real_offset = D.33825;
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            sp.182 = sp;
            sp = sp.182 + 8;
            D.36487 = iargs[0];
            *sp.182 = D.36487;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.36472>;
      <D.36470>:
      klass.157 = klass;
      D.31957 = *sp;
      ins = handle_castclass (cfg, klass.157, D.31957, context_used);
      D.31510 = cfg->exception_type;
      if (D.31510 != 0) goto exception_exit; else goto <D.36488>;
      <D.36488>:
      bblock.113 = cfg->cbb;
      bblock = bblock.113;
      sp.183 = sp;
      sp = sp.183 + 8;
      *sp.183 = ins;
      ip = ip + 5;
      <D.36472>:
      <D.36408>:
      goto <D.27857>;
      <D.28287>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.36490>; else goto <D.36491>;
      <D.36490>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36492>; else goto <D.36493>;
      <D.36492>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36494>; else goto <D.36495>;
      <D.36494>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36495>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36493>:
      D.36496 = mini_get_debug_options ();
      D.36497 = D.36496->break_on_unverified;
      if (D.36497 != 0) goto <D.36498>; else goto unverified;
      <D.36498>:
      raise (5);
      <D.36491>:
      sp = sp + 18446744073709551608;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.36499>; else goto <D.36500>;
      <D.36499>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36501>; else goto <D.36502>;
      <D.36501>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36503>; else goto <D.36504>;
      <D.36503>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36504>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36502>:
      D.36505 = mini_get_debug_options ();
      D.36506 = D.36505->break_on_unverified;
      if (D.36506 != 0) goto <D.36507>; else goto unverified;
      <D.36507>:
      raise (5);
      <D.36500>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.184 = mini_get_class (method, token, generic_context);
      klass = klass.184;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.36509>; else goto <D.36511>;
      <D.36511>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.36509>; else goto <D.36510>;
      <D.36509>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.36512 = mini_get_debug_options ();
      D.36513 = D.36512->break_on_unverified;
      if (D.36513 != 0) goto <D.36514>; else goto load_error;
      <D.36514>:
      raise (5);
      <D.36510>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 != 6) goto <D.36515>; else goto <D.36516>;
      <D.36515>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36517>; else goto <D.36518>;
      <D.36517>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36519>; else goto <D.36520>;
      <D.36519>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36520>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36518>:
      D.36521 = mini_get_debug_options ();
      D.36522 = D.36521->break_on_unverified;
      if (D.36522 != 0) goto <D.36523>; else goto unverified;
      <D.36523>:
      raise (5);
      <D.36516>:
      klass.157 = klass;
      context_used = mini_class_check_context_used (cfg, klass.157);
      if (context_used == 0) goto <D.36526>; else goto <D.36524>;
      <D.36526>:
      klass.157 = klass;
      D.36527 = mini_class_has_reference_variant_generic_argument (cfg, klass.157, context_used);
      if (D.36527 != 0) goto <D.36528>; else goto <D.36524>;
      <D.36528>:
      {
        struct MonoMethod * mono_isinst;
        struct MonoInst * args[3];

        try
          {
            mono_isinst = mono_marshal_get_isinst_with_cache ();
            D.31957 = *sp;
            args[0] = D.31957;
            D.30941 = cfg->mempool;
            D.36529 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.36529;
            D.36530 = args[1];
            D.36530 = args[1];
            D.36530->data.op[1].const_val = 0;
            D.36531 = D.36530->data.op[1].const_val;
            D.36530->data.op[0].const_val = D.36531;
            D.36530 = args[1];
            D.36530 = args[1];
            D.36530->prev = 0B;
            D.36532 = D.36530->prev;
            D.36530->next = D.36532;
            D.36530 = args[1];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36534>; else goto <D.36535>;
            <D.36534>:
            iftmp.185 = 734;
            goto <D.36536>;
            <D.36535>:
            iftmp.185 = 363;
            <D.36536>:
            D.36530->opcode = iftmp.185;
            D.36530 = args[1];
            D.36530->flags = 0;
            D.36530 = args[1];
            D.36530->type = 0;
            D.36530 = args[1];
            D.36530->dreg = -1;
            D.36530 = args[1];
            D.36530 = args[1];
            D.36530 = args[1];
            D.36530->sreg3 = -1;
            D.36537 = D.36530->sreg3;
            D.36530->sreg2 = D.36537;
            D.36538 = D.36530->sreg2;
            D.36530->sreg1 = D.36538;
            D.36530 = args[1];
            D.31162 = cfg->ip;
            D.36530->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36539>; else goto <D.36540>;
            <D.36539>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36541 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36541;
              group->prev = 0B;
              D.36542 = group->prev;
              group->next = D.36542;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36543 = group->sreg3;
              group->sreg2 = D.36543;
              D.36544 = group->sreg2;
              group->sreg1 = D.36544;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              klass.157 = klass;
              group->data.op[0].src = klass.157;
              group->data.op[1].src = 11B;
              D.36530 = args[1];
              D.36545 = got_loc->dreg;
              D.36530->sreg1 = D.36545;
              D.36530 = args[1];
              D.36530->data.op[1].p = group;
            }
            goto <D.36546>;
            <D.36540>:
            D.36530 = args[1];
            klass.157 = klass;
            D.36530->data.op[0].p = klass.157;
            D.36530 = args[1];
            D.36530->data.op[1].src = 11B;
            <D.36546>:
            D.36530 = args[1];
            D.36530->type = 3;
            D.36530 = args[1];
            D.36547 = alloc_dreg (cfg, 3);
            D.36548 = (int) D.36547;
            D.36530->dreg = D.36548;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36549>; else goto <D.36550>;
            <D.36549>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36530 = args[1];
            D.31191->next = D.36530;
            D.36530 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36530->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36530 = args[1];
            bblock.113->last_ins = D.36530;
            goto <D.36551>;
            <D.36550>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36530 = args[1];
            bblock.113->last_ins = D.36530;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36551>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36552>; else goto <D.36553>;
            <D.36552>:
            D.30941 = cfg->mempool;
            D.36554 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36554;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->data.op[1].const_val = 0;
            D.36556 = D.36555->data.op[1].const_val;
            D.36555->data.op[0].const_val = D.36556;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->prev = 0B;
            D.36557 = D.36555->prev;
            D.36555->next = D.36557;
            D.36555 = args[2];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36559>; else goto <D.36560>;
            <D.36559>:
            iftmp.186 = 734;
            goto <D.36561>;
            <D.36560>:
            iftmp.186 = 363;
            <D.36561>:
            D.36555->opcode = iftmp.186;
            D.36555 = args[2];
            D.36555->flags = 0;
            D.36555 = args[2];
            D.36555->type = 0;
            D.36555 = args[2];
            D.36555->dreg = -1;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->sreg3 = -1;
            D.36562 = D.36555->sreg3;
            D.36555->sreg2 = D.36562;
            D.36563 = D.36555->sreg2;
            D.36555->sreg1 = D.36563;
            D.36555 = args[2];
            D.31162 = cfg->ip;
            D.36555->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36564>; else goto <D.36565>;
            <D.36564>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36566 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36566;
              group->prev = 0B;
              D.36567 = group->prev;
              group->next = D.36567;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36568 = group->sreg3;
              group->sreg2 = D.36568;
              D.36569 = group->sreg2;
              group->sreg1 = D.36569;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 43B;
              D.36555 = args[2];
              D.36570 = got_loc->dreg;
              D.36555->sreg1 = D.36570;
              D.36555 = args[2];
              D.36555->data.op[1].p = group;
            }
            goto <D.36571>;
            <D.36565>:
            D.36555 = args[2];
            D.36555->data.op[0].p = 0B;
            D.36555 = args[2];
            D.36555->data.op[1].src = 43B;
            <D.36571>:
            D.36555 = args[2];
            D.36555->type = 3;
            D.36555 = args[2];
            D.36572 = alloc_dreg (cfg, 3);
            D.36573 = (int) D.36572;
            D.36555->dreg = D.36573;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36574>; else goto <D.36575>;
            <D.36574>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36555 = args[2];
            D.31191->next = D.36555;
            D.36555 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36555->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36555 = args[2];
            bblock.113->last_ins = D.36555;
            goto <D.36576>;
            <D.36575>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36555 = args[2];
            bblock.113->last_ins = D.36555;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36576>:
            goto <D.36577>;
            <D.36553>:
            D.30941 = cfg->mempool;
            D.36578 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36578;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->data.op[1].const_val = 0;
            D.36556 = D.36555->data.op[1].const_val;
            D.36555->data.op[0].const_val = D.36556;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->prev = 0B;
            D.36557 = D.36555->prev;
            D.36555->next = D.36557;
            D.36555 = args[2];
            D.36555->opcode = 363;
            D.36555 = args[2];
            D.36555->flags = 0;
            D.36555 = args[2];
            D.36555->type = 0;
            D.36555 = args[2];
            D.36555->dreg = -1;
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555 = args[2];
            D.36555->sreg3 = -1;
            D.36562 = D.36555->sreg3;
            D.36555->sreg2 = D.36562;
            D.36563 = D.36555->sreg2;
            D.36555->sreg1 = D.36563;
            D.36555 = args[2];
            D.31162 = cfg->ip;
            D.36555->cil_code = D.31162;
            D.36555 = args[2];
            D.30966 = cfg->domain;
            D.36579 = mono_domain_alloc0 (D.30966, 8);
            D.36555->data.op[0].p = D.36579;
            D.36555 = args[2];
            D.36555->type = 3;
            D.36555 = args[2];
            D.36580 = alloc_dreg (cfg, 3);
            D.36581 = (int) D.36580;
            D.36555->dreg = D.36581;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36582>; else goto <D.36583>;
            <D.36582>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36555 = args[2];
            D.31191->next = D.36555;
            D.36555 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36555->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36555 = args[2];
            bblock.113->last_ins = D.36555;
            goto <D.36584>;
            <D.36583>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36555 = args[2];
            bblock.113->last_ins = D.36555;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36584>:
            <D.36577>:
            sp.187 = sp;
            sp = sp.187 + 8;
            D.36586 = mono_emit_method_call (cfg, mono_isinst, &args, 0B);
            *sp.187 = D.36586;
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.36525>;
      <D.36524>:
      if (context_used == 0) goto <D.36590>; else goto <D.36587>;
      <D.36590>:
      klass.157 = klass;
      D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
      D.36475 = D.36474 & 4194304;
      if (D.36475 != 0) goto <D.36588>; else goto <D.36591>;
      <D.36591>:
      klass.157 = klass;
      D.36477 = klass.157->flags;
      D.36478 = D.36477 & 32;
      if (D.36478 != 0) goto <D.36588>; else goto <D.36587>;
      <D.36588>:
      {
        struct MonoMethod * mono_isinst;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.157 = klass;
            mono_isinst = mono_marshal_get_isinst (klass.157);
            D.31957 = *sp;
            iargs[0] = D.31957;
            D.36592 = mono_method_signature (mono_isinst);
            D.31108 = cfg->real_offset;
            costs = inline_method (cfg, mono_isinst, D.36592, &iargs, ip, D.31108, dont_inline, 1);
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.36593>;
            <D.36593>:
            D.36594 = costs <= 0;
            D.36595 = (long int) D.36594;
            D.36596 = __builtin_expect (D.36595, 0);
            if (D.36596 != 0) goto <D.36597>; else goto <D.36598>;
            <D.36597>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9584, "costs > 0");
            <D.36598>:
            ip = ip + 5;
            D.31108 = cfg->real_offset;
            D.33825 = D.31108 + 5;
            cfg->real_offset = D.33825;
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            sp.188 = sp;
            sp = sp.188 + 8;
            D.36600 = iargs[0];
            *sp.188 = D.36600;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.36589>;
      <D.36587>:
      klass.157 = klass;
      D.31957 = *sp;
      ins = handle_isinst (cfg, klass.157, D.31957, context_used);
      D.31510 = cfg->exception_type;
      if (D.31510 != 0) goto exception_exit; else goto <D.36601>;
      <D.36601>:
      bblock.113 = cfg->cbb;
      bblock = bblock.113;
      sp.189 = sp;
      sp = sp.189 + 8;
      *sp.189 = ins;
      ip = ip + 5;
      <D.36589>:
      <D.36525>:
      goto <D.27857>;
      <D.28297>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.36603>; else goto <D.36604>;
      <D.36603>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36605>; else goto <D.36606>;
      <D.36605>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36607>; else goto <D.36608>;
      <D.36607>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36608>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36606>:
      D.36609 = mini_get_debug_options ();
      D.36610 = D.36609->break_on_unverified;
      if (D.36610 != 0) goto <D.36611>; else goto unverified;
      <D.36611>:
      raise (5);
      <D.36604>:
      sp = sp + 18446744073709551608;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.36612>; else goto <D.36613>;
      <D.36612>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36614>; else goto <D.36615>;
      <D.36614>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36616>; else goto <D.36617>;
      <D.36616>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36617>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36615>:
      D.36618 = mini_get_debug_options ();
      D.36619 = D.36618->break_on_unverified;
      if (D.36619 != 0) goto <D.36620>; else goto unverified;
      <D.36620>:
      raise (5);
      <D.36613>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.190 = mini_get_class (method, token, generic_context);
      klass = klass.190;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.36622>; else goto <D.36624>;
      <D.36624>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.36622>; else goto <D.36623>;
      <D.36622>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.36625 = mini_get_debug_options ();
      D.36626 = D.36625->break_on_unverified;
      if (D.36626 != 0) goto <D.36627>; else goto load_error;
      <D.36627>:
      raise (5);
      <D.36623>:
      klass.157 = klass;
      mono_save_token_info (cfg, image, token, klass.157);
      klass.157 = klass;
      context_used = mini_class_check_context_used (cfg, klass.157);
      klass.157 = klass;
      D.36628 = mini_is_gsharedvt_klass (cfg, klass.157);
      if (D.36628 != 0) goto <D.36629>; else goto <D.36630>;
      <D.36629>:
      klass.157 = klass;
      D.31957 = *sp;
      D.36631 = handle_unbox_gsharedvt (cfg, klass.157, D.31957, &bblock);
      *sp = D.36631;
      sp = sp + 8;
      ip = ip + 5;
      inline_costs = inline_costs + 2;
      goto <D.27857>;
      <D.36630>:
      klass.157 = klass;
      D.36632 = generic_class_is_reference_type (cfg, klass.157);
      if (D.36632 != 0) goto <D.36633>; else goto <D.36634>;
      <D.36633>:
      if (context_used == 0) goto <D.36637>; else goto <D.36635>;
      <D.36637>:
      klass.157 = klass;
      D.36638 = mini_class_has_reference_variant_generic_argument (cfg, klass.157, context_used);
      if (D.36638 != 0) goto <D.36639>; else goto <D.36635>;
      <D.36639>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * args[3];

        try
          {
            mono_castclass = mono_marshal_get_castclass_with_cache ();
            D.31957 = *sp;
            args[0] = D.31957;
            D.30941 = cfg->mempool;
            D.36640 = mono_mempool_alloc (D.30941, 80);
            args[1] = D.36640;
            D.36641 = args[1];
            D.36641 = args[1];
            D.36641->data.op[1].const_val = 0;
            D.36642 = D.36641->data.op[1].const_val;
            D.36641->data.op[0].const_val = D.36642;
            D.36641 = args[1];
            D.36641 = args[1];
            D.36641->prev = 0B;
            D.36643 = D.36641->prev;
            D.36641->next = D.36643;
            D.36641 = args[1];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36645>; else goto <D.36646>;
            <D.36645>:
            iftmp.191 = 734;
            goto <D.36647>;
            <D.36646>:
            iftmp.191 = 363;
            <D.36647>:
            D.36641->opcode = iftmp.191;
            D.36641 = args[1];
            D.36641->flags = 0;
            D.36641 = args[1];
            D.36641->type = 0;
            D.36641 = args[1];
            D.36641->dreg = -1;
            D.36641 = args[1];
            D.36641 = args[1];
            D.36641 = args[1];
            D.36641->sreg3 = -1;
            D.36648 = D.36641->sreg3;
            D.36641->sreg2 = D.36648;
            D.36649 = D.36641->sreg2;
            D.36641->sreg1 = D.36649;
            D.36641 = args[1];
            D.31162 = cfg->ip;
            D.36641->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36650>; else goto <D.36651>;
            <D.36650>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36652 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36652;
              group->prev = 0B;
              D.36653 = group->prev;
              group->next = D.36653;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36654 = group->sreg3;
              group->sreg2 = D.36654;
              D.36655 = group->sreg2;
              group->sreg1 = D.36655;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              klass.157 = klass;
              group->data.op[0].src = klass.157;
              group->data.op[1].src = 11B;
              D.36641 = args[1];
              D.36656 = got_loc->dreg;
              D.36641->sreg1 = D.36656;
              D.36641 = args[1];
              D.36641->data.op[1].p = group;
            }
            goto <D.36657>;
            <D.36651>:
            D.36641 = args[1];
            klass.157 = klass;
            D.36641->data.op[0].p = klass.157;
            D.36641 = args[1];
            D.36641->data.op[1].src = 11B;
            <D.36657>:
            D.36641 = args[1];
            D.36641->type = 3;
            D.36641 = args[1];
            D.36658 = alloc_dreg (cfg, 3);
            D.36659 = (int) D.36658;
            D.36641->dreg = D.36659;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36660>; else goto <D.36661>;
            <D.36660>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36641 = args[1];
            D.31191->next = D.36641;
            D.36641 = args[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36641->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36641 = args[1];
            bblock.113->last_ins = D.36641;
            goto <D.36662>;
            <D.36661>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36641 = args[1];
            bblock.113->last_ins = D.36641;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36662>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36663>; else goto <D.36664>;
            <D.36663>:
            D.30941 = cfg->mempool;
            D.36665 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36665;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->data.op[1].const_val = 0;
            D.36667 = D.36666->data.op[1].const_val;
            D.36666->data.op[0].const_val = D.36667;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->prev = 0B;
            D.36668 = D.36666->prev;
            D.36666->next = D.36668;
            D.36666 = args[2];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36670>; else goto <D.36671>;
            <D.36670>:
            iftmp.192 = 734;
            goto <D.36672>;
            <D.36671>:
            iftmp.192 = 363;
            <D.36672>:
            D.36666->opcode = iftmp.192;
            D.36666 = args[2];
            D.36666->flags = 0;
            D.36666 = args[2];
            D.36666->type = 0;
            D.36666 = args[2];
            D.36666->dreg = -1;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->sreg3 = -1;
            D.36673 = D.36666->sreg3;
            D.36666->sreg2 = D.36673;
            D.36674 = D.36666->sreg2;
            D.36666->sreg1 = D.36674;
            D.36666 = args[2];
            D.31162 = cfg->ip;
            D.36666->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.36675>; else goto <D.36676>;
            <D.36675>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.36677 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.36677;
              group->prev = 0B;
              D.36678 = group->prev;
              group->next = D.36678;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.36679 = group->sreg3;
              group->sreg2 = D.36679;
              D.36680 = group->sreg2;
              group->sreg1 = D.36680;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = 0B;
              group->data.op[1].src = 43B;
              D.36666 = args[2];
              D.36681 = got_loc->dreg;
              D.36666->sreg1 = D.36681;
              D.36666 = args[2];
              D.36666->data.op[1].p = group;
            }
            goto <D.36682>;
            <D.36676>:
            D.36666 = args[2];
            D.36666->data.op[0].p = 0B;
            D.36666 = args[2];
            D.36666->data.op[1].src = 43B;
            <D.36682>:
            D.36666 = args[2];
            D.36666->type = 3;
            D.36666 = args[2];
            D.36683 = alloc_dreg (cfg, 3);
            D.36684 = (int) D.36683;
            D.36666->dreg = D.36684;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36685>; else goto <D.36686>;
            <D.36685>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36666 = args[2];
            D.31191->next = D.36666;
            D.36666 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36666->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36666 = args[2];
            bblock.113->last_ins = D.36666;
            goto <D.36687>;
            <D.36686>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36666 = args[2];
            bblock.113->last_ins = D.36666;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36687>:
            goto <D.36688>;
            <D.36664>:
            D.30941 = cfg->mempool;
            D.36689 = mono_mempool_alloc (D.30941, 80);
            args[2] = D.36689;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->data.op[1].const_val = 0;
            D.36667 = D.36666->data.op[1].const_val;
            D.36666->data.op[0].const_val = D.36667;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->prev = 0B;
            D.36668 = D.36666->prev;
            D.36666->next = D.36668;
            D.36666 = args[2];
            D.36666->opcode = 363;
            D.36666 = args[2];
            D.36666->flags = 0;
            D.36666 = args[2];
            D.36666->type = 0;
            D.36666 = args[2];
            D.36666->dreg = -1;
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666 = args[2];
            D.36666->sreg3 = -1;
            D.36673 = D.36666->sreg3;
            D.36666->sreg2 = D.36673;
            D.36674 = D.36666->sreg2;
            D.36666->sreg1 = D.36674;
            D.36666 = args[2];
            D.31162 = cfg->ip;
            D.36666->cil_code = D.31162;
            D.36666 = args[2];
            D.30966 = cfg->domain;
            D.36690 = mono_domain_alloc0 (D.30966, 8);
            D.36666->data.op[0].p = D.36690;
            D.36666 = args[2];
            D.36666->type = 3;
            D.36666 = args[2];
            D.36691 = alloc_dreg (cfg, 3);
            D.36692 = (int) D.36691;
            D.36666->dreg = D.36692;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36693>; else goto <D.36694>;
            <D.36693>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36666 = args[2];
            D.31191->next = D.36666;
            D.36666 = args[2];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.36666->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.36666 = args[2];
            bblock.113->last_ins = D.36666;
            goto <D.36695>;
            <D.36694>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.36666 = args[2];
            bblock.113->last_ins = D.36666;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36695>:
            <D.36688>:
            sp.193 = sp;
            sp = sp.193 + 8;
            D.36697 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
            *sp.193 = D.36697;
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.36636>;
      <D.36635>:
      if (context_used == 0) goto <D.36701>; else goto <D.36698>;
      <D.36701>:
      klass.157 = klass;
      D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
      D.36475 = D.36474 & 4194304;
      if (D.36475 != 0) goto <D.36699>; else goto <D.36702>;
      <D.36702>:
      klass.157 = klass;
      D.36477 = klass.157->flags;
      D.36478 = D.36477 & 32;
      if (D.36478 != 0) goto <D.36699>; else goto <D.36698>;
      <D.36699>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.157 = klass;
            mono_castclass = mono_marshal_get_castclass (klass.157);
            D.31957 = *sp;
            iargs[0] = D.31957;
            D.36703 = mono_method_signature (mono_castclass);
            D.31108 = cfg->real_offset;
            costs = inline_method (cfg, mono_castclass, D.36703, &iargs, ip, D.31108, dont_inline, 1);
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.36704>;
            <D.36704>:
            D.36705 = costs <= 0;
            D.36706 = (long int) D.36705;
            D.36707 = __builtin_expect (D.36706, 0);
            if (D.36707 != 0) goto <D.36708>; else goto <D.36709>;
            <D.36708>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9658, "costs > 0");
            <D.36709>:
            ip = ip + 5;
            D.31108 = cfg->real_offset;
            D.33825 = D.31108 + 5;
            cfg->real_offset = D.33825;
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            sp.194 = sp;
            sp = sp.194 + 8;
            D.36711 = iargs[0];
            *sp.194 = D.36711;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.36700>;
      <D.36698>:
      klass.157 = klass;
      D.31957 = *sp;
      ins = handle_castclass (cfg, klass.157, D.31957, context_used);
      D.31510 = cfg->exception_type;
      if (D.31510 != 0) goto exception_exit; else goto <D.36712>;
      <D.36712>:
      bblock.113 = cfg->cbb;
      bblock = bblock.113;
      sp.195 = sp;
      sp = sp.195 + 8;
      *sp.195 = ins;
      ip = ip + 5;
      <D.36700>:
      <D.36636>:
      goto <D.27857>;
      <D.36634>:
      klass.157 = klass;
      D.36714 = mono_class_is_nullable (klass.157);
      if (D.36714 != 0) goto <D.36715>; else goto <D.36716>;
      <D.36715>:
      D.31957 = *sp;
      klass.157 = klass;
      ins = handle_unbox_nullable (cfg, D.31957, klass.157, context_used);
      sp.196 = sp;
      sp = sp.196 + 8;
      *sp.196 = ins;
      ip = ip + 5;
      goto <D.27857>;
      <D.36716>:
      klass.157 = klass;
      ins = handle_unbox (cfg, klass.157, sp, context_used);
      *sp = ins;
      ip = ip + 5;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      klass.157 = klass;
      D.35726 = &klass.157->byval_arg;
      D.36718 = mono_type_to_load_membase (cfg, D.35726);
      D.36719 = (short unsigned int) D.36718;
      ins->opcode = D.36719;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->dreg = 0;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      klass.157 = klass;
      D.35726 = &klass.157->byval_arg;
      type_to_eval_stack_type (cfg, D.35726, ins);
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.36720 = alloc_dreg (cfg, D.31706);
      D.36721 = (int) D.36720;
      ins->dreg = D.36721;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.36722>; else goto <D.36723>;
      <D.36722>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.36724>;
      <D.36723>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.36724>:
      sp.197 = sp;
      sp = sp.197 + 8;
      *sp.197 = ins;
      inline_costs = inline_costs + 2;
      goto <D.27857>;
      <D.28307>:
      {
        struct MonoInst * val;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.36726>; else goto <D.36727>;
        <D.36726>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.36728>; else goto <D.36729>;
        <D.36728>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.36730>; else goto <D.36731>;
        <D.36730>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36731>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36729>:
        D.36732 = mini_get_debug_options ();
        D.36733 = D.36732->break_on_unverified;
        if (D.36733 != 0) goto <D.36734>; else goto unverified;
        <D.36734>:
        raise (5);
        <D.36727>:
        sp = sp + 18446744073709551608;
        val = *sp;
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.36735>; else goto <D.36736>;
        <D.36735>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.36737>; else goto <D.36738>;
        <D.36737>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.36739>; else goto <D.36740>;
        <D.36739>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36740>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36738>:
        D.36741 = mini_get_debug_options ();
        D.36742 = D.36741->break_on_unverified;
        if (D.36742 != 0) goto <D.36743>; else goto unverified;
        <D.36743>:
        raise (5);
        <D.36736>:
        token = MEM[(const guint32 *)ip + 1B];
        klass.198 = mini_get_class (method, token, generic_context);
        klass = klass.198;
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.36745>; else goto <D.36747>;
        <D.36747>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.36745>; else goto <D.36746>;
        <D.36745>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.36748 = mini_get_debug_options ();
        D.36749 = D.36748->break_on_unverified;
        if (D.36749 != 0) goto <D.36750>; else goto load_error;
        <D.36750>:
        raise (5);
        <D.36746>:
        klass.157 = klass;
        mono_save_token_info (cfg, image, token, klass.157);
        klass.157 = klass;
        context_used = mini_class_check_context_used (cfg, klass.157);
        klass.157 = klass;
        D.36751 = generic_class_is_reference_type (cfg, klass.157);
        if (D.36751 != 0) goto <D.36752>; else goto <D.36753>;
        <D.36752>:
        sp.199 = sp;
        sp = sp.199 + 8;
        *sp.199 = val;
        ip = ip + 5;
        goto <D.27857>;
        <D.36753>:
        D.36755 = mono_defaults.void_class;
        klass.157 = klass;
        if (D.36755 == klass.157) goto <D.36756>; else goto <D.36757>;
        <D.36756>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.36758>; else goto <D.36759>;
        <D.36758>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.36760>; else goto <D.36761>;
        <D.36760>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36761>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36759>:
        D.36762 = mini_get_debug_options ();
        D.36763 = D.36762->break_on_unverified;
        if (D.36763 != 0) goto <D.36764>; else goto unverified;
        <D.36764>:
        raise (5);
        <D.36757>:
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        D.31957 = *sp;
        D.36765 = target_type_is_incompatible (cfg, D.35726, D.31957);
        if (D.36765 != 0) goto <D.36766>; else goto <D.36767>;
        <D.36766>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.36768>; else goto <D.36769>;
        <D.36768>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.36770>; else goto <D.36771>;
        <D.36770>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36771>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36769>:
        D.36772 = mini_get_debug_options ();
        D.36773 = D.36772->break_on_unverified;
        if (D.36773 != 0) goto <D.36774>; else goto unverified;
        <D.36774>:
        raise (5);
        <D.36767>:
        klass.157 = klass;
        D.36777 = mono_class_is_nullable (klass.157);
        if (D.36777 == 0) goto <D.36778>; else goto <D.36779>;
        <D.36778>:
        D.32381 = ip + 5;
        if (D.32381 < end) goto <D.36780>; else goto <D.36781>;
        <D.36780>:
        bblock.70 = bblock;
        D.33876 = ip + 5;
        D.36782 = ip_in_bb (cfg, bblock.70, D.33876);
        if (D.36782 != 0) goto <D.36783>; else goto <D.36784>;
        <D.36783>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        if (D.32923 == 58) goto <D.36775>; else goto <D.36785>;
        <D.36785>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        if (D.32923 == 45) goto <D.36775>; else goto <D.36786>;
        <D.36786>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        if (D.32923 == 57) goto <D.36775>; else goto <D.36787>;
        <D.36787>:
        D.32381 = ip + 5;
        D.32923 = *D.32381;
        if (D.32923 == 44) goto <D.36775>; else goto <D.36776>;
        <D.36775>:
        {
          gboolean is_true;
          int dreg;
          struct MonoBasicBlock * true_bb;
          struct MonoBasicBlock * false_bb;

          D.32381 = ip + 5;
          D.32923 = *D.32381;
          if (D.32923 == 58) goto <D.36789>; else goto <D.36792>;
          <D.36792>:
          D.32381 = ip + 5;
          D.32923 = *D.32381;
          if (D.32923 == 45) goto <D.36789>; else goto <D.36790>;
          <D.36789>:
          iftmp.200 = 1;
          goto <D.36791>;
          <D.36790>:
          iftmp.200 = 0;
          <D.36791>:
          is_true = iftmp.200;
          ip = ip + 5;
          D.31021 = cfg->verbose_level;
          if (D.31021 > 3) goto <D.36793>; else goto <D.36794>;
          <D.36793>:
          bblock.70 = bblock;
          D.31836 = bblock.70->block_num;
          sp.77 = (long int) sp;
          stack_start.78 = (long int) stack_start;
          D.31730 = sp.77 - stack_start.78;
          D.31731 = D.31730 /[ex] 8;
          D.31732 = (int) D.31731;
          D.36795 = mono_disasm_code_one (0B, method, ip, 0B);
          printf ("converting (in B%d: stack: %d) %s", D.31836, D.31732, D.36795);
          printf ("<box+brtrue opt>\n");
          <D.36794>:
          D.31838 = *ip;
          D.31839 = (int) D.31838;
          switch (D.31839) <default: <D.28318>, case 44: <D.28314>, case 45: <D.28313>, case 57: <D.28317>, case 58: <D.28316>>
          <D.28313>:
          <D.28314>:
          D.31968 = ip + 2;
          if (D.31968 > end) goto <D.36796>; else goto <D.36797>;
          <D.36796>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.36798>; else goto <D.36799>;
          <D.36798>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.36800>; else goto <D.36801>;
          <D.36800>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.36801>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36799>:
          D.36802 = mini_get_debug_options ();
          D.36803 = D.36802->break_on_unverified;
          if (D.36803 != 0) goto <D.36804>; else goto unverified;
          <D.36804>:
          raise (5);
          <D.36797>:
          ip = ip + 1;
          D.31838 = *ip;
          D.34564 = (signed char) D.31838;
          D.34565 = (sizetype) D.34564;
          D.34566 = D.34565 + 1;
          target = ip + D.34566;
          ip = ip + 1;
          goto <D.28315>;
          <D.28316>:
          <D.28317>:
          D.32381 = ip + 5;
          if (D.32381 > end) goto <D.36805>; else goto <D.36806>;
          <D.36805>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.36807>; else goto <D.36808>;
          <D.36807>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.36809>; else goto <D.36810>;
          <D.36809>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.36810>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36808>:
          D.36811 = mini_get_debug_options ();
          D.36812 = D.36811->break_on_unverified;
          if (D.36812 != 0) goto <D.36813>; else goto unverified;
          <D.36813>:
          raise (5);
          <D.36806>:
          ip = ip + 1;
          D.32491 = MEM[(const guint32 *)ip];
          D.34705 = (int) D.32491;
          D.34706 = (sizetype) D.34705;
          D.34707 = D.34706 + 4;
          target = ip + D.34707;
          ip = ip + 4;
          goto <D.28315>;
          <D.28318>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9757);
          <D.28315>:
          D.31071 = cfg->cil_offset_to_bb;
          target.136 = (long int) target;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.34568 = target.136 - D.31077;
          D.34569 = (long unsigned int) D.34568;
          D.34570 = D.34569 * 8;
          D.34571 = D.31071 + D.34570;
          true_bb = *D.34571;
          if (true_bb == 0B) goto <D.36814>; else goto <D.36815>;
          <D.36814>:
          if (target >= end) goto <D.36816>; else goto <D.36818>;
          <D.36818>:
          D.31088 = header->code;
          if (D.31088 > target) goto <D.36816>; else goto <D.36817>;
          <D.36816>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.36819>; else goto <D.36820>;
          <D.36819>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.36821>; else goto <D.36822>;
          <D.36821>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.36822>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36820>:
          D.36823 = mini_get_debug_options ();
          D.36824 = D.36823->break_on_unverified;
          if (D.36824 != 0) goto <D.36825>; else goto unverified;
          <D.36825>:
          raise (5);
          <D.36817>:
          D.30941 = cfg->mempool;
          true_bb = mono_mempool_alloc0 (D.30941, 296);
          D.31048 = cfg->num_bblocks;
          D.36826 = D.31048;
          D.36827 = D.36826 + 1;
          cfg->num_bblocks = D.36827;
          D.36828 = (int) D.36826;
          true_bb->block_num = D.36828;
          true_bb->cil_code = target;
          D.36829 = true_bb->cil_code;
          if (D.36829 != 0B) goto <D.36830>; else goto <D.36831>;
          <D.36830>:
          D.31071 = cfg->cil_offset_to_bb;
          D.36829 = true_bb->cil_code;
          D.36832 = (long int) D.36829;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.36833 = D.36832 - D.31077;
          D.36834 = (long unsigned int) D.36833;
          D.36835 = D.36834 * 8;
          D.36836 = D.31071 + D.36835;
          *D.36836 = true_bb;
          <D.36831>:
          D.31108 = cfg->real_offset;
          true_bb->real_offset = D.31108;
          <D.36815>:
          D.31071 = cfg->cil_offset_to_bb;
          ip.75 = (long int) ip;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.31666 = ip.75 - D.31077;
          D.31667 = (long unsigned int) D.31666;
          D.31668 = D.31667 * 8;
          D.31669 = D.31071 + D.31668;
          false_bb = *D.31669;
          if (false_bb == 0B) goto <D.36837>; else goto <D.36838>;
          <D.36837>:
          if (ip >= end) goto <D.36839>; else goto <D.36841>;
          <D.36841>:
          D.31088 = header->code;
          if (D.31088 > ip) goto <D.36839>; else goto <D.36840>;
          <D.36839>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.36842>; else goto <D.36843>;
          <D.36842>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.36844>; else goto <D.36845>;
          <D.36844>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.36845>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36843>:
          D.36846 = mini_get_debug_options ();
          D.36847 = D.36846->break_on_unverified;
          if (D.36847 != 0) goto <D.36848>; else goto unverified;
          <D.36848>:
          raise (5);
          <D.36840>:
          D.30941 = cfg->mempool;
          false_bb = mono_mempool_alloc0 (D.30941, 296);
          D.31048 = cfg->num_bblocks;
          D.36849 = D.31048;
          D.36850 = D.36849 + 1;
          cfg->num_bblocks = D.36850;
          D.36851 = (int) D.36849;
          false_bb->block_num = D.36851;
          false_bb->cil_code = ip;
          D.36852 = false_bb->cil_code;
          if (D.36852 != 0B) goto <D.36853>; else goto <D.36854>;
          <D.36853>:
          D.31071 = cfg->cil_offset_to_bb;
          D.36852 = false_bb->cil_code;
          D.36855 = (long int) D.36852;
          D.31076 = cfg->cil_start;
          D.31077 = (long int) D.31076;
          D.36856 = D.36855 - D.31077;
          D.36857 = (long unsigned int) D.36856;
          D.36858 = D.36857 * 8;
          D.36859 = D.31071 + D.36858;
          *D.36859 = false_bb;
          <D.36854>:
          D.31108 = cfg->real_offset;
          false_bb->real_offset = D.31108;
          <D.36838>:
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, true_bb);
          bblock.113 = cfg->cbb;
          mono_link_bblock (cfg, bblock.113, false_bb);
          if (sp != stack_start) goto <D.36860>; else goto <D.36861>;
          <D.36860>:
          sp.77 = (long int) sp;
          stack_start.78 = (long int) stack_start;
          D.31730 = sp.77 - stack_start.78;
          D.31731 = D.31730 /[ex] 8;
          D.31732 = (int) D.31731;
          handle_stack_args (cfg, stack_start, D.31732);
          sp = stack_start;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31733 = D.31336 & 35184372088832;
          if (D.31733 != 0) goto <D.36862>; else goto <D.36863>;
          <D.36862>:
          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.36864>; else goto <D.36865>;
          <D.36864>:
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.36866>; else goto <D.36867>;
          <D.36866>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.36867>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36865>:
          D.36868 = mini_get_debug_options ();
          D.36869 = D.36868->break_on_unverified;
          if (D.36869 != 0) goto <D.36870>; else goto unverified;
          <D.36870>:
          raise (5);
          <D.36863>:
          <D.36861>:
          if (0 != 0) goto <D.36871>; else goto <D.36872>;
          <D.36871>:
          D.36873 = alloc_ireg (cfg);
          dreg = (int) D.36873;
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.36874 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36874;
            inst->prev = 0B;
            D.36875 = inst->prev;
            inst->next = D.36875;
            inst->opcode = 362;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36876 = inst->sreg3;
            inst->sreg2 = D.36876;
            D.36877 = inst->sreg2;
            inst->sreg1 = D.36877;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = dreg;
            inst->data.op[0].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36878>; else goto <D.36879>;
            <D.36878>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.36880>;
            <D.36879>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36880>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.36881 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36881;
            inst->prev = 0B;
            D.36882 = inst->prev;
            inst->next = D.36882;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36883 = inst->sreg3;
            inst->sreg2 = D.36883;
            D.36884 = inst->sreg2;
            inst->sreg1 = D.36884;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = -1;
            inst->sreg1 = dreg;
            D.36885 = is_true == 0;
            D.36886 = (int) D.36885;
            D.36887 = (long int) D.36886;
            inst->data.op[1].const_val = D.36887;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36888>; else goto <D.36889>;
            <D.36888>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.36890>;
            <D.36889>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36890>:
          }
          {
            struct MonoInst * ins;

            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.36891 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.36891;
            ins->prev = 0B;
            D.36892 = ins->prev;
            ins->next = D.36892;
            ins->opcode = 648;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.36893 = ins->sreg3;
            ins->sreg2 = D.36893;
            D.36894 = ins->sreg2;
            ins->sreg1 = D.36894;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.30941 = cfg->mempool;
            D.36895 = mono_mempool_alloc (D.30941, 16);
            ins->data.op[1].many_blocks = D.36895;
            D.36896 = ins->data.op[1].many_blocks;
            *D.36896 = true_bb;
            D.36896 = ins->data.op[1].many_blocks;
            D.36897 = D.36896 + 8;
            *D.36897 = false_bb;
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, true_bb);
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, false_bb);
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.36898>; else goto <D.36899>;
            <D.36898>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.36900>;
            <D.36899>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.36900>:
          }
          goto <D.36901>;
          <D.36872>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 442;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          if (is_true != 0) goto <D.36903>; else goto <D.36904>;
          <D.36903>:
          iftmp.201 = true_bb;
          goto <D.36905>;
          <D.36904>:
          iftmp.201 = false_bb;
          <D.36905>:
          ins->data.op[0].target_block = iftmp.201;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.36906>; else goto <D.36907>;
          <D.36906>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.36908>;
          <D.36907>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.36908>:
          <D.36901>:
          start_new_bblock = 1;
          goto <D.27857>;
        }
        <D.36776>:
        <D.36784>:
        <D.36781>:
        <D.36779>:
        sp.202 = sp;
        sp = sp.202 + 8;
        klass.157 = klass;
        D.36910 = handle_box (cfg, val, klass.157, context_used, &bblock);
        *sp.202 = D.36910;
        D.31510 = cfg->exception_type;
        if (D.31510 != 0) goto exception_exit; else goto <D.36911>;
        <D.36911>:
        ip = ip + 5;
        inline_costs = inline_costs + 1;
        goto <D.27857>;
      }
      <D.28322>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.36912>; else goto <D.36913>;
      <D.36912>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36914>; else goto <D.36915>;
      <D.36914>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36916>; else goto <D.36917>;
      <D.36916>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36917>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36915>:
      D.36918 = mini_get_debug_options ();
      D.36919 = D.36918->break_on_unverified;
      if (D.36919 != 0) goto <D.36920>; else goto unverified;
      <D.36920>:
      raise (5);
      <D.36913>:
      sp = sp + 18446744073709551608;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.36921>; else goto <D.36922>;
      <D.36921>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.36923>; else goto <D.36924>;
      <D.36923>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.36925>; else goto <D.36926>;
      <D.36925>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.36926>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.36924>:
      D.36927 = mini_get_debug_options ();
      D.36928 = D.36927->break_on_unverified;
      if (D.36928 != 0) goto <D.36929>; else goto unverified;
      <D.36929>:
      raise (5);
      <D.36922>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.203 = mini_get_class (method, token, generic_context);
      klass = klass.203;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.36931>; else goto <D.36933>;
      <D.36933>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.36931>; else goto <D.36932>;
      <D.36931>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.36934 = mini_get_debug_options ();
      D.36935 = D.36934->break_on_unverified;
      if (D.36935 != 0) goto <D.36936>; else goto load_error;
      <D.36936>:
      raise (5);
      <D.36932>:
      klass.157 = klass;
      mono_save_token_info (cfg, image, token, klass.157);
      klass.157 = klass;
      context_used = mini_class_check_context_used (cfg, klass.157);
      klass.157 = klass;
      D.36937 = mono_class_is_nullable (klass.157);
      if (D.36937 != 0) goto <D.36938>; else goto <D.36939>;
      <D.36938>:
      {
        struct MonoInst * val;

        D.31957 = *sp;
        klass.157 = klass;
        val = handle_unbox_nullable (cfg, D.31957, klass.157, context_used);
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.36941 = val->dreg;
        D.36942 = (unsigned int) D.36941;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.36942 < D.32058) goto <D.36943>; else goto <D.36944>;
        <D.36943>:
        D.32061 = cfg->vreg_to_inst;
        D.36941 = val->dreg;
        D.36945 = (long unsigned int) D.36941;
        D.36946 = D.36945 * 8;
        D.36947 = D.32061 + D.36946;
        iftmp.204 = *D.36947;
        goto <D.36948>;
        <D.36944>:
        iftmp.204 = 0B;
        <D.36948>:
        ins->data.op[0].p = iftmp.204;
        D.36941 = val->dreg;
        D.36942 = (unsigned int) D.36941;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.36942 < D.32058) goto <D.36950>; else goto <D.36951>;
        <D.36950>:
        D.32061 = cfg->vreg_to_inst;
        D.36941 = val->dreg;
        D.36945 = (long unsigned int) D.36941;
        D.36946 = D.36945 * 8;
        D.36947 = D.32061 + D.36946;
        iftmp.205 = *D.36947;
        goto <D.36952>;
        <D.36951>:
        iftmp.205 = 0B;
        <D.36952>:
        D.36941 = val->dreg;
        D.36942 = (unsigned int) D.36941;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.36942 < D.32058) goto <D.36954>; else goto <D.36955>;
        <D.36954>:
        D.32061 = cfg->vreg_to_inst;
        D.36941 = val->dreg;
        D.36945 = (long unsigned int) D.36941;
        D.36946 = D.36945 * 8;
        D.36947 = D.32061 + D.36946;
        iftmp.206 = *D.36947;
        goto <D.36956>;
        <D.36955>:
        iftmp.206 = 0B;
        <D.36956>:
        D.36957 = iftmp.206->flags;
        D.36958 = D.36957 | 16;
        iftmp.205->flags = D.36958;
        ins->type = 5;
        D.36941 = val->dreg;
        D.36942 = (unsigned int) D.36941;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.36942 < D.32058) goto <D.36960>; else goto <D.36961>;
        <D.36960>:
        D.32061 = cfg->vreg_to_inst;
        D.36941 = val->dreg;
        D.36945 = (long unsigned int) D.36941;
        D.36946 = D.36945 * 8;
        D.36947 = D.32061 + D.36946;
        iftmp.207 = *D.36947;
        goto <D.36962>;
        <D.36961>:
        iftmp.207 = 0B;
        <D.36962>:
        D.36963 = iftmp.207->klass;
        ins->klass = D.36963;
        D.36964 = alloc_dreg (cfg, 5);
        D.36965 = (int) D.36964;
        ins->dreg = D.36965;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.36966>; else goto <D.36967>;
        <D.36966>:
        D.36941 = val->dreg;
        D.36942 = (unsigned int) D.36941;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.36942 < D.32058) goto <D.36969>; else goto <D.36970>;
        <D.36969>:
        D.32061 = cfg->vreg_to_inst;
        D.36941 = val->dreg;
        D.36945 = (long unsigned int) D.36941;
        D.36946 = D.36945 * 8;
        D.36947 = D.32061 + D.36946;
        iftmp.208 = *D.36947;
        goto <D.36971>;
        <D.36970>:
        iftmp.208 = 0B;
        <D.36971>:
        D.36972 = iftmp.208->data.op[1].vtype;
        D.36973 = mini_is_gsharedvt_variable_type (cfg, D.36972);
        if (D.36973 != 0) goto <D.36974>; else goto <D.36975>;
        <D.36974>:
        handle_gsharedvt_ldaddr (cfg);
        <D.36975>:
        <D.36967>:
        if (0 != 0) goto <D.36976>; else goto <D.36977>;
        <D.36976>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.36941 = val->dreg;
          D.36942 = (unsigned int) D.36941;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.36942 < D.32058) goto <D.36980>; else goto <D.36981>;
          <D.36980>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36945 = (long unsigned int) D.36941;
          D.36946 = D.36945 * 8;
          D.36947 = D.32061 + D.36946;
          iftmp.210 = *D.36947;
          goto <D.36982>;
          <D.36981>:
          iftmp.210 = 0B;
          <D.36982>:
          D.36983 = iftmp.210->dreg;
          D.36984 = D.36983 + 1;
          D.36985 = (unsigned int) D.36984;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.36985 < D.32058) goto <D.36986>; else goto <D.36987>;
          <D.36986>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36942 = (unsigned int) D.36941;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.36942 < D.32058) goto <D.36989>; else goto <D.36990>;
          <D.36989>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36945 = (long unsigned int) D.36941;
          D.36946 = D.36945 * 8;
          D.36947 = D.32061 + D.36946;
          iftmp.211 = *D.36947;
          goto <D.36991>;
          <D.36990>:
          iftmp.211 = 0B;
          <D.36991>:
          D.36992 = iftmp.211->dreg;
          D.36993 = (sizetype) D.36992;
          D.36994 = D.36993 + 1;
          D.36995 = D.36994 * 8;
          D.36996 = D.32061 + D.36995;
          iftmp.209 = *D.36996;
          goto <D.36997>;
          <D.36987>:
          iftmp.209 = 0B;
          <D.36997>:
          var1 = iftmp.209;
          D.36941 = val->dreg;
          D.36942 = (unsigned int) D.36941;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.36942 < D.32058) goto <D.37000>; else goto <D.37001>;
          <D.37000>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36945 = (long unsigned int) D.36941;
          D.36946 = D.36945 * 8;
          D.36947 = D.32061 + D.36946;
          iftmp.213 = *D.36947;
          goto <D.37002>;
          <D.37001>:
          iftmp.213 = 0B;
          <D.37002>:
          D.37003 = iftmp.213->dreg;
          D.37004 = D.37003 + 2;
          D.37005 = (unsigned int) D.37004;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.37005 < D.32058) goto <D.37006>; else goto <D.37007>;
          <D.37006>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36942 = (unsigned int) D.36941;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.36942 < D.32058) goto <D.37009>; else goto <D.37010>;
          <D.37009>:
          D.32061 = cfg->vreg_to_inst;
          D.36941 = val->dreg;
          D.36945 = (long unsigned int) D.36941;
          D.36946 = D.36945 * 8;
          D.36947 = D.32061 + D.36946;
          iftmp.214 = *D.36947;
          goto <D.37011>;
          <D.37010>:
          iftmp.214 = 0B;
          <D.37011>:
          D.37012 = iftmp.214->dreg;
          D.37013 = (sizetype) D.37012;
          D.37014 = D.37013 + 2;
          D.37015 = D.37014 * 8;
          D.37016 = D.32061 + D.37015;
          iftmp.212 = *D.37016;
          goto <D.37017>;
          <D.37007>:
          iftmp.212 = 0B;
          <D.37017>:
          var2 = iftmp.212;
          D.37018 = var1 == 0B;
          D.37019 = (long int) D.37018;
          D.37020 = __builtin_expect (D.37019, 0);
          if (D.37020 != 0) goto <D.37021>; else goto <D.37022>;
          <D.37021>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9818, "var1");
          <D.37022>:
          D.37023 = var2 == 0B;
          D.37024 = (long int) D.37023;
          D.37025 = __builtin_expect (D.37024, 0);
          if (D.37025 != 0) goto <D.37026>; else goto <D.37027>;
          <D.37026>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9818, "var2");
          <D.37027>:
          D.37028 = var1->flags;
          D.37029 = D.37028 | 16;
          var1->flags = D.37029;
          D.37030 = var2->flags;
          D.37031 = D.37030 | 16;
          var2->flags = D.37031;
        }
        <D.36977>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.37032>; else goto <D.37033>;
        <D.37032>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.37034>;
        <D.37033>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.37034>:
        sp.215 = sp;
        sp = sp.215 + 8;
        *sp.215 = ins;
      }
      goto <D.37036>;
      <D.36939>:
      klass.157 = klass;
      ins = handle_unbox (cfg, klass.157, sp, context_used);
      sp.216 = sp;
      sp = sp.216 + 8;
      *sp.216 = ins;
      <D.37036>:
      ip = ip + 5;
      inline_costs = inline_costs + 2;
      goto <D.27857>;
      <D.28326>:
      <D.28327>:
      <D.28328>:
      <D.28329>:
      <D.28330>:
      <D.28331>:
      {
        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.31838 = *ip;
        op = (int) D.31838;
        op.217 = (unsigned int) op;
        D.37039 = op.217 + 4294967173;
        D.37040 = D.37039 <= 2;
        is_instance = (gboolean) D.37040;
        if (is_instance != 0) goto <D.37041>; else goto <D.37042>;
        <D.37041>:
        if (op == 125) goto <D.37043>; else goto <D.37044>;
        <D.37043>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 15) goto <D.37045>; else goto <D.37046>;
        <D.37045>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37047>; else goto <D.37048>;
        <D.37047>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37049>; else goto <D.37050>;
        <D.37049>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37050>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37048>:
        D.37051 = mini_get_debug_options ();
        D.37052 = D.37051->break_on_unverified;
        if (D.37052 != 0) goto <D.37053>; else goto unverified;
        <D.37053>:
        raise (5);
        <D.37046>:
        sp = sp + 18446744073709551600;
        store_val = MEM[(struct MonoInst * *)sp + 8B];
        goto <D.37054>;
        <D.37044>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.37055>; else goto <D.37056>;
        <D.37055>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37057>; else goto <D.37058>;
        <D.37057>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37059>; else goto <D.37060>;
        <D.37059>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37060>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37058>:
        D.37061 = mini_get_debug_options ();
        D.37062 = D.37061->break_on_unverified;
        if (D.37062 != 0) goto <D.37063>; else goto unverified;
        <D.37063>:
        raise (5);
        <D.37056>:
        sp = sp + 18446744073709551608;
        <D.37054>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        D.37066 = D.33688 + 255;
        if (D.37066 <= 1) goto <D.37064>; else goto <D.37067>;
        <D.37067>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 4) goto <D.37064>; else goto <D.37065>;
        <D.37064>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37068>; else goto <D.37069>;
        <D.37068>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37070>; else goto <D.37071>;
        <D.37070>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37071>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37069>:
        D.37072 = mini_get_debug_options ();
        D.37073 = D.37072->break_on_unverified;
        if (D.37073 != 0) goto <D.37074>; else goto unverified;
        <D.37074>:
        raise (5);
        <D.37065>:
        D.31838 = *ip;
        if (D.31838 != 123) goto <D.37075>; else goto <D.37076>;
        <D.37075>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 7) goto <D.37077>; else goto <D.37078>;
        <D.37077>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37079>; else goto <D.37080>;
        <D.37079>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37081>; else goto <D.37082>;
        <D.37081>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37082>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37080>:
        D.37083 = mini_get_debug_options ();
        D.37084 = D.37083->break_on_unverified;
        if (D.37084 != 0) goto <D.37085>; else goto unverified;
        <D.37085>:
        raise (5);
        <D.37078>:
        <D.37076>:
        goto <D.37086>;
        <D.37042>:
        if (op == 128) goto <D.37087>; else goto <D.37088>;
        <D.37087>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.37089>; else goto <D.37090>;
        <D.37089>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37091>; else goto <D.37092>;
        <D.37091>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37093>; else goto <D.37094>;
        <D.37093>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37094>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37092>:
        D.37095 = mini_get_debug_options ();
        D.37096 = D.37095->break_on_unverified;
        if (D.37096 != 0) goto <D.37097>; else goto unverified;
        <D.37097>:
        raise (5);
        <D.37090>:
        sp = sp + 18446744073709551608;
        store_val = *sp;
        <D.37088>:
        <D.37086>:
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.37098>; else goto <D.37099>;
        <D.37098>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37100>; else goto <D.37101>;
        <D.37100>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37102>; else goto <D.37103>;
        <D.37102>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37103>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37101>:
        D.37104 = mini_get_debug_options ();
        D.37105 = D.37104->break_on_unverified;
        if (D.37105 != 0) goto <D.37106>; else goto unverified;
        <D.37106>:
        raise (5);
        <D.37099>:
        token = MEM[(const guint32 *)ip + 1B];
        D.30883 = BIT_FIELD_REF <*method, 64, 256>;
        D.30884 = D.30883 & 124;
        if (D.30884 != 0) goto <D.37107>; else goto <D.37108>;
        <D.37107>:
        field = mono_method_get_wrapper_data (method, token);
        klass.218 = field->parent;
        klass = klass.218;
        goto <D.37110>;
        <D.37108>:
        field = mono_field_from_token (image, token, &klass, generic_context);
        <D.37110>:
        if (field == 0B) goto <D.37111>; else goto <D.37112>;
        <D.37111>:
        D.37113 = mini_get_debug_options ();
        D.37114 = D.37113->break_on_unverified;
        if (D.37114 != 0) goto <D.37115>; else goto load_error;
        <D.37115>:
        raise (5);
        <D.37112>:
        if (dont_verify == 0) goto <D.37116>; else goto <D.37117>;
        <D.37116>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.32845 = D.31336 & 70368744177664;
        if (D.32845 == 0) goto <D.37118>; else goto <D.37119>;
        <D.37118>:
        D.37120 = mono_method_can_access_field (method, field);
        if (D.37120 == 0) goto <D.37121>; else goto <D.37122>;
        <D.37121>:
        {
          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.37123 = monoeg_g_strdup_printf ("Field `%s\' is inaccessible from method `%s\'\n", field_fname, method_fname);
          cfg->exception_message = D.37123;
          monoeg_g_free (method_fname);
          monoeg_g_free (field_fname);
          goto exception_exit;
        }
        <D.37122>:
        <D.37119>:
        <D.37117>:
        klass.157 = klass;
        mono_class_init (klass.157);
        if (is_instance != 0) goto <D.37124>; else goto <D.37125>;
        <D.37124>:
        D.31838 = *ip;
        if (D.31838 != 124) goto <D.37126>; else goto <D.37127>;
        <D.37126>:
        D.37128 = is_magic_tls_access (field);
        if (D.37128 != 0) goto <D.37129>; else goto <D.37130>;
        <D.37129>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37131>; else goto <D.37132>;
        <D.37131>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37133>; else goto <D.37134>;
        <D.37133>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37134>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37132>:
        D.37135 = mini_get_debug_options ();
        D.37136 = D.37135->break_on_unverified;
        if (D.37136 != 0) goto <D.37137>; else goto unverified;
        <D.37137>:
        raise (5);
        <D.37130>:
        <D.37127>:
        <D.37125>:
        if (is_instance == 0) goto <D.37138>; else goto <D.37139>;
        <D.37138>:
        D.37140 = mono_security_get_mode ();
        if (D.37140 == 1) goto <D.37141>; else goto <D.37142>;
        <D.37141>:
        bblock.70 = bblock;
        ensure_method_is_allowed_to_access_field (cfg, method, field, bblock.70, ip);
        <D.37142>:
        <D.37139>:
        if (is_instance != 0) goto <D.37143>; else goto <D.37144>;
        <D.37143>:
        D.37145 = field->type;
        D.37146 = D.37145->attrs;
        D.37147 = (int) D.37146;
        D.37148 = D.37147 & 16;
        if (D.37148 != 0) goto <D.37149>; else goto <D.37150>;
        <D.37149>:
        switch (op) <default: <D.28348>, case 123: <D.28344>, case 124: <D.28347>, case 125: <D.28346>>
        <D.28344>:
        op = 126;
        goto <D.28345>;
        <D.28346>:
        op = 128;
        goto <D.28345>;
        <D.28347>:
        op = 127;
        goto <D.28345>;
        <D.28348>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9915);
        <D.28345>:
        is_instance = 0;
        <D.37150>:
        <D.37144>:
        klass.157 = klass;
        context_used = mini_class_check_context_used (cfg, klass.157);
        klass.157 = klass;
        D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
        D.37152 = D.36474 & 8;
        if (D.37152 != 0) goto <D.37153>; else goto <D.37154>;
        <D.37153>:
        D.37155 = field->offset;
        D.37156 = (unsigned int) D.37155;
        iftmp.219 = D.37156 + 4294967280;
        goto <D.37157>;
        <D.37154>:
        D.37155 = field->offset;
        iftmp.219 = (guint) D.37155;
        <D.37157>:
        foffset = iftmp.219;
        if (op == 125) goto <D.37158>; else goto <D.37159>;
        <D.37158>:
        D.37145 = field->type;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.37160 = target_type_is_incompatible (cfg, D.37145, D.33090);
        if (D.37160 != 0) goto <D.37161>; else goto <D.37162>;
        <D.37161>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37163>; else goto <D.37164>;
        <D.37163>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37165>; else goto <D.37166>;
        <D.37165>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37166>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37164>:
        D.37167 = mini_get_debug_options ();
        D.37168 = D.37167->break_on_unverified;
        if (D.37168 != 0) goto <D.37169>; else goto unverified;
        <D.37169>:
        raise (5);
        <D.37162>:
        klass.157 = klass;
        D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
        D.36475 = D.36474 & 4194304;
        if (D.36475 != 0) goto <D.37174>; else goto <D.37170>;
        <D.37174>:
        D.30911 = cfg->method;
        D.37175 = mono_method_signature (D.30911);
        D.37176 = BIT_FIELD_REF <*D.37175, 64, 64>;
        D.37177 = D.37176 & 18014398509481984;
        if (D.37177 == 0) goto <D.37171>; else goto <D.37178>;
        <D.37178>:
        D.31957 = *sp;
        D.33692 = D.31957->opcode;
        if (D.33692 != 424) goto <D.37171>; else goto <D.37179>;
        <D.37179>:
        D.31957 = *sp;
        D.37180 = D.31957->sreg1;
        D.31559 = cfg->args;
        D.31560 = *D.31559;
        D.31574 = D.31560->dreg;
        if (D.37180 != D.31574) goto <D.37171>; else goto <D.37170>;
        <D.37170>:
        klass.157 = klass;
        D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
        D.37181 = D.36474 & 8388608;
        if (D.37181 != 0) goto <D.37171>; else goto <D.37182>;
        <D.37182>:
        D.37183 = mono_defaults.marshalbyrefobject_class;
        klass.157 = klass;
        if (D.37183 == klass.157) goto <D.37171>; else goto <D.37172>;
        <D.37171>:
        {
          struct MonoMethod * stfld_wrapper;
          struct MonoInst * iargs[5];

          try
            {
              D.37145 = field->type;
              stfld_wrapper = mono_marshal_get_stfld_wrapper (D.37145);
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.37184>; else goto <D.37185>;
              <D.37184>:
              D.30878 = method->klass;
              D.32629 = D.30878->name_space;
              D.30878 = method->klass;
              D.32630 = D.30878->name;
              D.32631 = method->name;
              D.32632 = method->signature;
              D.32633 = D.32632->param_count;
              D.32634 = (int) D.32633;
              D.37186 = mono_opcode_name (op);
              D.37187 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.37186, "method-to-ir.c", 9933);
              cfg->exception_message = D.37187;
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.37188>; else goto <D.37189>;
              <D.37188>:
              D.32639 = cfg->exception_message;
              printf ("%s\n", D.32639);
              <D.37189>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.37185>:
              D.31957 = *sp;
              iargs[0] = D.31957;
              D.30941 = cfg->mempool;
              D.37190 = mono_mempool_alloc (D.30941, 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.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37195>; else goto <D.37196>;
              <D.37195>:
              iftmp.220 = 734;
              goto <D.37197>;
              <D.37196>:
              iftmp.220 = 363;
              <D.37197>:
              D.37191->opcode = iftmp.220;
              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.31162 = cfg->ip;
              D.37191->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37200>; else goto <D.37201>;
              <D.37200>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37202 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37202;
                group->prev = 0B;
                D.37203 = group->prev;
                group->next = D.37203;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37204 = group->sreg3;
                group->sreg2 = D.37204;
                D.37205 = group->sreg2;
                group->sreg1 = D.37205;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                klass.157 = klass;
                group->data.op[0].src = klass.157;
                group->data.op[1].src = 11B;
                D.37191 = iargs[1];
                D.37206 = got_loc->dreg;
                D.37191->sreg1 = D.37206;
                D.37191 = iargs[1];
                D.37191->data.op[1].p = group;
              }
              goto <D.37207>;
              <D.37201>:
              D.37191 = iargs[1];
              klass.157 = klass;
              D.37191->data.op[0].p = klass.157;
              D.37191 = iargs[1];
              D.37191->data.op[1].src = 11B;
              <D.37207>:
              D.37191 = iargs[1];
              D.37191->type = 3;
              D.37191 = iargs[1];
              D.37208 = alloc_dreg (cfg, 3);
              D.37209 = (int) D.37208;
              D.37191->dreg = D.37209;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37210>; else goto <D.37211>;
              <D.37210>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37191 = iargs[1];
              D.31191->next = D.37191;
              D.37191 = iargs[1];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37191->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37191 = iargs[1];
              bblock.113->last_ins = D.37191;
              goto <D.37212>;
              <D.37211>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37191 = iargs[1];
              bblock.113->last_ins = D.37191;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37212>:
              D.30941 = cfg->mempool;
              D.37213 = mono_mempool_alloc (D.30941, 80);
              iargs[2] = D.37213;
              D.37214 = iargs[2];
              D.37214 = iargs[2];
              D.37214->data.op[1].const_val = 0;
              D.37215 = D.37214->data.op[1].const_val;
              D.37214->data.op[0].const_val = D.37215;
              D.37214 = iargs[2];
              D.37214 = iargs[2];
              D.37214->prev = 0B;
              D.37216 = D.37214->prev;
              D.37214->next = D.37216;
              D.37214 = iargs[2];
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37218>; else goto <D.37219>;
              <D.37218>:
              iftmp.221 = 734;
              goto <D.37220>;
              <D.37219>:
              iftmp.221 = 363;
              <D.37220>:
              D.37214->opcode = iftmp.221;
              D.37214 = iargs[2];
              D.37214->flags = 0;
              D.37214 = iargs[2];
              D.37214->type = 0;
              D.37214 = iargs[2];
              D.37214->dreg = -1;
              D.37214 = iargs[2];
              D.37214 = iargs[2];
              D.37214 = iargs[2];
              D.37214->sreg3 = -1;
              D.37221 = D.37214->sreg3;
              D.37214->sreg2 = D.37221;
              D.37222 = D.37214->sreg2;
              D.37214->sreg1 = D.37222;
              D.37214 = iargs[2];
              D.31162 = cfg->ip;
              D.37214->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37223>; else goto <D.37224>;
              <D.37223>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37225 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37225;
                group->prev = 0B;
                D.37226 = group->prev;
                group->next = D.37226;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37227 = group->sreg3;
                group->sreg2 = D.37227;
                D.37228 = group->sreg2;
                group->sreg1 = D.37228;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = field;
                group->data.op[1].src = 13B;
                D.37214 = iargs[2];
                D.37229 = got_loc->dreg;
                D.37214->sreg1 = D.37229;
                D.37214 = iargs[2];
                D.37214->data.op[1].p = group;
              }
              goto <D.37230>;
              <D.37224>:
              D.37214 = iargs[2];
              D.37214->data.op[0].p = field;
              D.37214 = iargs[2];
              D.37214->data.op[1].src = 13B;
              <D.37230>:
              D.37214 = iargs[2];
              D.37214->type = 3;
              D.37214 = iargs[2];
              D.37231 = alloc_dreg (cfg, 3);
              D.37232 = (int) D.37231;
              D.37214->dreg = D.37232;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37233>; else goto <D.37234>;
              <D.37233>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37214 = iargs[2];
              D.31191->next = D.37214;
              D.37214 = iargs[2];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37214->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37214 = iargs[2];
              bblock.113->last_ins = D.37214;
              goto <D.37235>;
              <D.37234>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37214 = iargs[2];
              bblock.113->last_ins = D.37214;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37235>:
              D.30941 = cfg->mempool;
              D.37236 = mono_mempool_alloc (D.30941, 80);
              iargs[3] = D.37236;
              D.37237 = iargs[3];
              D.37237 = iargs[3];
              D.37237->data.op[1].const_val = 0;
              D.37238 = D.37237->data.op[1].const_val;
              D.37237->data.op[0].const_val = D.37238;
              D.37237 = iargs[3];
              D.37237 = iargs[3];
              D.37237->prev = 0B;
              D.37239 = D.37237->prev;
              D.37237->next = D.37239;
              D.37237 = iargs[3];
              D.37237->opcode = 362;
              D.37237 = iargs[3];
              D.37237->flags = 0;
              D.37237 = iargs[3];
              D.37237->type = 0;
              D.37237 = iargs[3];
              D.37237->dreg = -1;
              D.37237 = iargs[3];
              D.37237 = iargs[3];
              D.37237 = iargs[3];
              D.37237->sreg3 = -1;
              D.37240 = D.37237->sreg3;
              D.37237->sreg2 = D.37240;
              D.37241 = D.37237->sreg2;
              D.37237->sreg1 = D.37241;
              D.37237 = iargs[3];
              D.31162 = cfg->ip;
              D.37237->cil_code = D.31162;
              D.37237 = iargs[3];
              klass.157 = klass;
              D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
              D.37152 = D.36474 & 8;
              if (D.37152 != 0) goto <D.37243>; else goto <D.37244>;
              <D.37243>:
              D.37155 = field->offset;
              D.37245 = (long unsigned int) D.37155;
              D.37246 = D.37245 + 18446744073709551600;
              iftmp.222 = (mgreg_t) D.37246;
              goto <D.37247>;
              <D.37244>:
              D.37155 = field->offset;
              iftmp.222 = (mgreg_t) D.37155;
              <D.37247>:
              D.37237->data.op[0].const_val = iftmp.222;
              D.37237 = iargs[3];
              D.37237->type = 1;
              D.37237 = iargs[3];
              D.37248 = alloc_dreg (cfg, 1);
              D.37249 = (int) D.37248;
              D.37237->dreg = D.37249;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37250>; else goto <D.37251>;
              <D.37250>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37237 = iargs[3];
              D.31191->next = D.37237;
              D.37237 = iargs[3];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37237->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37237 = iargs[3];
              bblock.113->last_ins = D.37237;
              goto <D.37252>;
              <D.37251>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37237 = iargs[3];
              bblock.113->last_ins = D.37237;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37252>:
              D.36145 = MEM[(struct MonoInst * *)sp + 8B];
              iargs[4] = D.36145;
              D.31334 = cfg->opt;
              D.33798 = D.31334 & 4;
              if (D.33798 != 0) goto <D.37253>; else goto <D.37256>;
              <D.37256>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37253>; else goto <D.37254>;
              <D.37253>:
              D.37257 = mono_method_signature (stfld_wrapper);
              D.31108 = cfg->real_offset;
              costs = inline_method (cfg, stfld_wrapper, D.37257, &iargs, ip, D.31108, dont_inline, 1);
              D.31510 = cfg->exception_type;
              if (D.31510 != 0) goto exception_exit; else goto <D.37258>;
              <D.37258>:
              D.37259 = costs <= 0;
              D.37260 = (long int) D.37259;
              D.37261 = __builtin_expect (D.37260, 0);
              if (D.37261 != 0) goto <D.37262>; else goto <D.37263>;
              <D.37262>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9946, "costs > 0");
              <D.37263>:
              D.31108 = cfg->real_offset;
              D.33825 = D.31108 + 5;
              cfg->real_offset = D.33825;
              bblock.113 = cfg->cbb;
              bblock = bblock.113;
              inline_costs = inline_costs + costs;
              goto <D.37255>;
              <D.37254>:
              mono_emit_method_call (cfg, stfld_wrapper, &iargs, 0B);
              <D.37255>:
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.37173>;
        <D.37172>:
        {
          struct MonoInst * store;

          D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.31587 = D.30929 & 64;
          if (D.31587 != 0) goto <D.37264>; else goto <D.37265>;
          <D.37264>:
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37266 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37266;
            inst->prev = 0B;
            D.37267 = inst->prev;
            inst->next = D.37267;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37268 = inst->sreg3;
            inst->sreg2 = D.37268;
            D.37269 = inst->sreg2;
            inst->sreg1 = D.37269;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = -1;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            inst->sreg1 = D.32139;
            inst->data.op[1].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37270>; else goto <D.37271>;
            <D.37270>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37272>;
            <D.37271>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37272>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37273 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37273;
            inst->prev = 0B;
            D.37274 = inst->prev;
            inst->next = D.37274;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37275 = inst->sreg3;
            inst->sreg2 = D.37275;
            D.37276 = inst->sreg2;
            inst->sreg1 = D.37276;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->data.op[1].p = "NullReferenceException";
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37277>; else goto <D.37278>;
            <D.37277>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37279>;
            <D.37278>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37279>:
          }
          goto <D.37280>;
          <D.37265>:
          <D.37280>:
          klass.157 = klass;
          D.37281 = mini_is_gsharedvt_klass (cfg, klass.157);
          if (D.37281 != 0) goto <D.37282>; else goto <D.37283>;
          <D.37282>:
          {
            struct MonoInst * offset_ins;

            klass.157 = klass;
            context_used = mini_class_check_context_used (cfg, klass.157);
            offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
            D.37284 = alloc_ireg_mp (cfg);
            dreg = (int) D.37284;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = dreg;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ins->sreg1 = D.32139;
            D.37285 = offset_ins->dreg;
            ins->sreg2 = D.37285;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37286>; else goto <D.37287>;
            <D.37286>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37288>;
            <D.37287>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37288>:
            D.30941 = cfg->mempool;
            store = mono_mempool_alloc (D.30941, 80);
            store->data.op[1].const_val = 0;
            D.37289 = store->data.op[1].const_val;
            store->data.op[0].const_val = D.37289;
            store->prev = 0B;
            D.37290 = store->prev;
            store->next = D.37290;
            D.37145 = field->type;
            D.37291 = mono_type_to_store_membase (cfg, D.37145);
            D.37292 = (short unsigned int) D.37291;
            store->opcode = D.37292;
            store->flags = 0;
            store->type = 0;
            store->dreg = -1;
            store->sreg3 = -1;
            D.37293 = store->sreg3;
            store->sreg2 = D.37293;
            D.37294 = store->sreg2;
            store->sreg1 = D.37294;
            D.31162 = cfg->ip;
            store->cil_code = D.31162;
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            D.33091 = D.33090->dreg;
            store->sreg1 = D.33091;
            store->dreg = dreg;
            store->data.op[0].const_val = 0;
            D.37145 = field->type;
            type_to_eval_stack_type (cfg, D.37145, store);
            D.37145 = field->type;
            D.37295 = mono_class_from_mono_type (D.37145);
            store->klass = D.37295;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37296>; else goto <D.37297>;
            <D.37296>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = store;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            store->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = store;
            goto <D.37298>;
            <D.37297>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = store;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37298>:
          }
          goto <D.37299>;
          <D.37283>:
          D.30941 = cfg->mempool;
          store = mono_mempool_alloc (D.30941, 80);
          store->data.op[1].const_val = 0;
          D.37289 = store->data.op[1].const_val;
          store->data.op[0].const_val = D.37289;
          store->prev = 0B;
          D.37290 = store->prev;
          store->next = D.37290;
          D.37145 = field->type;
          D.37300 = mono_type_to_store_membase (cfg, D.37145);
          D.37301 = (short unsigned int) D.37300;
          store->opcode = D.37301;
          store->flags = 0;
          store->type = 0;
          store->dreg = -1;
          store->sreg3 = -1;
          D.37293 = store->sreg3;
          store->sreg2 = D.37293;
          D.37294 = store->sreg2;
          store->sreg1 = D.37294;
          D.31162 = cfg->ip;
          store->cil_code = D.31162;
          D.33089 = sp + 8;
          D.33090 = *D.33089;
          D.33091 = D.33090->dreg;
          store->sreg1 = D.33091;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          store->dreg = D.32139;
          D.37302 = (long int) foffset;
          store->data.op[0].const_val = D.37302;
          D.37145 = field->type;
          type_to_eval_stack_type (cfg, D.37145, store);
          D.37145 = field->type;
          D.37303 = mono_class_from_mono_type (D.37145);
          store->klass = D.37303;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37304>; else goto <D.37305>;
          <D.37304>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = store;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          store->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = store;
          goto <D.37306>;
          <D.37305>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = store;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37306>:
          <D.37299>:
          D.31957 = *sp;
          D.33692 = D.31957->opcode;
          if (D.33692 != 314) goto <D.37307>; else goto <D.37308>;
          <D.37307>:
          D.37309 = store->flags;
          D.37310 = D.37309 | 32;
          store->flags = D.37310;
          <D.37308>:
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.34146 = D.31336 & 1152921504606846976;
          if (D.34146 != 0) goto <D.37313>; else goto <D.37314>;
          <D.37313>:
          D.37145 = field->type;
          D.37315 = mini_type_to_stind (cfg, D.37145);
          if (D.37315 == 81) goto <D.37316>; else goto <D.37317>;
          <D.37316>:
          D.33089 = sp + 8;
          D.33090 = *D.33089;
          D.35301 = D.33090->opcode;
          if (D.35301 != 363) goto <D.37311>; else goto <D.37318>;
          <D.37318>:
          D.33089 = sp + 8;
          D.33090 = *D.33089;
          D.35326 = D.33090->data.op[0].const_val;
          if (D.35326 != 0) goto <D.37311>; else goto <D.37312>;
          <D.37311>:
          {
            struct MonoInst * ptr;
            int dreg;

            D.37319 = alloc_ireg_mp (cfg);
            dreg = (int) D.37319;
            D.30941 = cfg->mempool;
            ptr = mono_mempool_alloc (D.30941, 80);
            ptr->data.op[1].const_val = 0;
            D.37320 = ptr->data.op[1].const_val;
            ptr->data.op[0].const_val = D.37320;
            ptr->prev = 0B;
            D.37321 = ptr->prev;
            ptr->next = D.37321;
            ptr->opcode = 538;
            ptr->flags = 0;
            ptr->type = 0;
            ptr->dreg = -1;
            ptr->sreg3 = -1;
            D.37322 = ptr->sreg3;
            ptr->sreg2 = D.37322;
            D.37323 = ptr->sreg2;
            ptr->sreg1 = D.37323;
            D.31162 = cfg->ip;
            ptr->cil_code = D.31162;
            ptr->dreg = dreg;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ptr->sreg1 = D.32139;
            D.37302 = (long int) foffset;
            ptr->data.op[1].const_val = D.37302;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37324>; else goto <D.37325>;
            <D.37324>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ptr;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ptr->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ptr;
            goto <D.37326>;
            <D.37325>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ptr;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37326>:
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            emit_write_barrier (cfg, ptr, D.33090);
          }
          <D.37312>:
          <D.37317>:
          <D.37314>:
          D.37309 = store->flags;
          D.35267 = (unsigned char) ins_flag;
          D.37327 = D.37309 | D.35267;
          store->flags = D.37327;
        }
        <D.37173>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27857>;
        <D.37159>:
        if (is_instance != 0) goto <D.37332>; else goto <D.37328>;
        <D.37332>:
        klass.157 = klass;
        D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
        D.36475 = D.36474 & 4194304;
        if (D.36475 != 0) goto <D.37333>; else goto <D.37329>;
        <D.37333>:
        D.30911 = cfg->method;
        D.37334 = mono_method_signature (D.30911);
        D.37335 = BIT_FIELD_REF <*D.37334, 64, 64>;
        D.37336 = D.37335 & 18014398509481984;
        if (D.37336 == 0) goto <D.37330>; else goto <D.37337>;
        <D.37337>:
        D.31957 = *sp;
        D.33692 = D.31957->opcode;
        if (D.33692 != 424) goto <D.37330>; else goto <D.37338>;
        <D.37338>:
        D.31957 = *sp;
        D.37180 = D.31957->sreg1;
        D.31559 = cfg->args;
        D.31560 = *D.31559;
        D.31574 = D.31560->dreg;
        if (D.37180 != D.31574) goto <D.37330>; else goto <D.37329>;
        <D.37329>:
        klass.157 = klass;
        D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
        D.37181 = D.36474 & 8388608;
        if (D.37181 != 0) goto <D.37330>; else goto <D.37339>;
        <D.37339>:
        D.37183 = mono_defaults.marshalbyrefobject_class;
        klass.157 = klass;
        if (D.37183 == klass.157) goto <D.37330>; else goto <D.37328>;
        <D.37330>:
        {
          struct MonoMethod * wrapper;
          struct MonoInst * iargs[4];

          try
            {
              if (op == 124) goto <D.37341>; else goto <D.37342>;
              <D.37341>:
              D.37145 = field->type;
              iftmp.223 = mono_marshal_get_ldflda_wrapper (D.37145);
              goto <D.37343>;
              <D.37342>:
              D.37145 = field->type;
              iftmp.223 = mono_marshal_get_ldfld_wrapper (D.37145);
              <D.37343>:
              wrapper = iftmp.223;
              D.31089 = cfg->gsharedvt;
              if (D.31089 != 0) goto <D.37344>; else goto <D.37345>;
              <D.37344>:
              D.30878 = method->klass;
              D.32629 = D.30878->name_space;
              D.30878 = method->klass;
              D.32630 = D.30878->name;
              D.32631 = method->name;
              D.32632 = method->signature;
              D.32633 = D.32632->param_count;
              D.32634 = (int) D.32633;
              D.37346 = mono_opcode_name (op);
              D.37347 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.37346, "method-to-ir.c", 10000);
              cfg->exception_message = D.37347;
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.37348>; else goto <D.37349>;
              <D.37348>:
              D.32639 = cfg->exception_message;
              printf ("%s\n", D.32639);
              <D.37349>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.37345>:
              D.31957 = *sp;
              iargs[0] = D.31957;
              D.30941 = cfg->mempool;
              D.37350 = mono_mempool_alloc (D.30941, 80);
              iargs[1] = D.37350;
              D.37351 = iargs[1];
              D.37351 = iargs[1];
              D.37351->data.op[1].const_val = 0;
              D.37352 = D.37351->data.op[1].const_val;
              D.37351->data.op[0].const_val = D.37352;
              D.37351 = iargs[1];
              D.37351 = iargs[1];
              D.37351->prev = 0B;
              D.37353 = D.37351->prev;
              D.37351->next = D.37353;
              D.37351 = iargs[1];
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37355>; else goto <D.37356>;
              <D.37355>:
              iftmp.224 = 734;
              goto <D.37357>;
              <D.37356>:
              iftmp.224 = 363;
              <D.37357>:
              D.37351->opcode = iftmp.224;
              D.37351 = iargs[1];
              D.37351->flags = 0;
              D.37351 = iargs[1];
              D.37351->type = 0;
              D.37351 = iargs[1];
              D.37351->dreg = -1;
              D.37351 = iargs[1];
              D.37351 = iargs[1];
              D.37351 = iargs[1];
              D.37351->sreg3 = -1;
              D.37358 = D.37351->sreg3;
              D.37351->sreg2 = D.37358;
              D.37359 = D.37351->sreg2;
              D.37351->sreg1 = D.37359;
              D.37351 = iargs[1];
              D.31162 = cfg->ip;
              D.37351->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37360>; else goto <D.37361>;
              <D.37360>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37362 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37362;
                group->prev = 0B;
                D.37363 = group->prev;
                group->next = D.37363;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37364 = group->sreg3;
                group->sreg2 = D.37364;
                D.37365 = group->sreg2;
                group->sreg1 = D.37365;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                klass.157 = klass;
                group->data.op[0].src = klass.157;
                group->data.op[1].src = 11B;
                D.37351 = iargs[1];
                D.37366 = got_loc->dreg;
                D.37351->sreg1 = D.37366;
                D.37351 = iargs[1];
                D.37351->data.op[1].p = group;
              }
              goto <D.37367>;
              <D.37361>:
              D.37351 = iargs[1];
              klass.157 = klass;
              D.37351->data.op[0].p = klass.157;
              D.37351 = iargs[1];
              D.37351->data.op[1].src = 11B;
              <D.37367>:
              D.37351 = iargs[1];
              D.37351->type = 3;
              D.37351 = iargs[1];
              D.37368 = alloc_dreg (cfg, 3);
              D.37369 = (int) D.37368;
              D.37351->dreg = D.37369;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37370>; else goto <D.37371>;
              <D.37370>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37351 = iargs[1];
              D.31191->next = D.37351;
              D.37351 = iargs[1];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37351->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37351 = iargs[1];
              bblock.113->last_ins = D.37351;
              goto <D.37372>;
              <D.37371>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37351 = iargs[1];
              bblock.113->last_ins = D.37351;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37372>:
              D.30941 = cfg->mempool;
              D.37373 = mono_mempool_alloc (D.30941, 80);
              iargs[2] = D.37373;
              D.37374 = iargs[2];
              D.37374 = iargs[2];
              D.37374->data.op[1].const_val = 0;
              D.37375 = D.37374->data.op[1].const_val;
              D.37374->data.op[0].const_val = D.37375;
              D.37374 = iargs[2];
              D.37374 = iargs[2];
              D.37374->prev = 0B;
              D.37376 = D.37374->prev;
              D.37374->next = D.37376;
              D.37374 = iargs[2];
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37378>; else goto <D.37379>;
              <D.37378>:
              iftmp.225 = 734;
              goto <D.37380>;
              <D.37379>:
              iftmp.225 = 363;
              <D.37380>:
              D.37374->opcode = iftmp.225;
              D.37374 = iargs[2];
              D.37374->flags = 0;
              D.37374 = iargs[2];
              D.37374->type = 0;
              D.37374 = iargs[2];
              D.37374->dreg = -1;
              D.37374 = iargs[2];
              D.37374 = iargs[2];
              D.37374 = iargs[2];
              D.37374->sreg3 = -1;
              D.37381 = D.37374->sreg3;
              D.37374->sreg2 = D.37381;
              D.37382 = D.37374->sreg2;
              D.37374->sreg1 = D.37382;
              D.37374 = iargs[2];
              D.31162 = cfg->ip;
              D.37374->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37383>; else goto <D.37384>;
              <D.37383>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37385 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37385;
                group->prev = 0B;
                D.37386 = group->prev;
                group->next = D.37386;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37387 = group->sreg3;
                group->sreg2 = D.37387;
                D.37388 = group->sreg2;
                group->sreg1 = D.37388;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = field;
                group->data.op[1].src = 13B;
                D.37374 = iargs[2];
                D.37389 = got_loc->dreg;
                D.37374->sreg1 = D.37389;
                D.37374 = iargs[2];
                D.37374->data.op[1].p = group;
              }
              goto <D.37390>;
              <D.37384>:
              D.37374 = iargs[2];
              D.37374->data.op[0].p = field;
              D.37374 = iargs[2];
              D.37374->data.op[1].src = 13B;
              <D.37390>:
              D.37374 = iargs[2];
              D.37374->type = 3;
              D.37374 = iargs[2];
              D.37391 = alloc_dreg (cfg, 3);
              D.37392 = (int) D.37391;
              D.37374->dreg = D.37392;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37393>; else goto <D.37394>;
              <D.37393>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37374 = iargs[2];
              D.31191->next = D.37374;
              D.37374 = iargs[2];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37374->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37374 = iargs[2];
              bblock.113->last_ins = D.37374;
              goto <D.37395>;
              <D.37394>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37374 = iargs[2];
              bblock.113->last_ins = D.37374;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37395>:
              D.30941 = cfg->mempool;
              D.37396 = mono_mempool_alloc (D.30941, 80);
              iargs[3] = D.37396;
              D.37397 = iargs[3];
              D.37397 = iargs[3];
              D.37397->data.op[1].const_val = 0;
              D.37398 = D.37397->data.op[1].const_val;
              D.37397->data.op[0].const_val = D.37398;
              D.37397 = iargs[3];
              D.37397 = iargs[3];
              D.37397->prev = 0B;
              D.37399 = D.37397->prev;
              D.37397->next = D.37399;
              D.37397 = iargs[3];
              D.37397->opcode = 362;
              D.37397 = iargs[3];
              D.37397->flags = 0;
              D.37397 = iargs[3];
              D.37397->type = 0;
              D.37397 = iargs[3];
              D.37397->dreg = -1;
              D.37397 = iargs[3];
              D.37397 = iargs[3];
              D.37397 = iargs[3];
              D.37397->sreg3 = -1;
              D.37400 = D.37397->sreg3;
              D.37397->sreg2 = D.37400;
              D.37401 = D.37397->sreg2;
              D.37397->sreg1 = D.37401;
              D.37397 = iargs[3];
              D.31162 = cfg->ip;
              D.37397->cil_code = D.31162;
              D.37397 = iargs[3];
              klass.157 = klass;
              D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
              D.37152 = D.36474 & 8;
              if (D.37152 != 0) goto <D.37403>; else goto <D.37404>;
              <D.37403>:
              D.37155 = field->offset;
              D.37245 = (long unsigned int) D.37155;
              D.37246 = D.37245 + 18446744073709551600;
              iftmp.226 = (mgreg_t) D.37246;
              goto <D.37405>;
              <D.37404>:
              D.37155 = field->offset;
              iftmp.226 = (mgreg_t) D.37155;
              <D.37405>:
              D.37397->data.op[0].const_val = iftmp.226;
              D.37397 = iargs[3];
              D.37397->type = 1;
              D.37397 = iargs[3];
              D.37406 = alloc_dreg (cfg, 1);
              D.37407 = (int) D.37406;
              D.37397->dreg = D.37407;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37408>; else goto <D.37409>;
              <D.37408>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37397 = iargs[3];
              D.31191->next = D.37397;
              D.37397 = iargs[3];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37397->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37397 = iargs[3];
              bblock.113->last_ins = D.37397;
              goto <D.37410>;
              <D.37409>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37397 = iargs[3];
              bblock.113->last_ins = D.37397;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37410>:
              D.31334 = cfg->opt;
              D.33798 = D.31334 & 4;
              if (D.33798 != 0) goto <D.37411>; else goto <D.37414>;
              <D.37414>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37411>; else goto <D.37412>;
              <D.37411>:
              D.37415 = mono_method_signature (wrapper);
              D.31108 = cfg->real_offset;
              costs = inline_method (cfg, wrapper, D.37415, &iargs, ip, D.31108, dont_inline, 1);
              D.31510 = cfg->exception_type;
              if (D.31510 != 0) goto exception_exit; else goto <D.37416>;
              <D.37416>:
              bblock.113 = cfg->cbb;
              bblock = bblock.113;
              D.37259 = costs <= 0;
              D.37260 = (long int) D.37259;
              D.37261 = __builtin_expect (D.37260, 0);
              if (D.37261 != 0) goto <D.37417>; else goto <D.37418>;
              <D.37417>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10011, "costs > 0");
              <D.37418>:
              D.31108 = cfg->real_offset;
              D.33825 = D.31108 + 5;
              cfg->real_offset = D.33825;
              sp.227 = sp;
              sp = sp.227 + 8;
              D.37420 = iargs[0];
              *sp.227 = D.37420;
              inline_costs = inline_costs + costs;
              goto <D.37413>;
              <D.37412>:
              ins = mono_emit_method_call (cfg, wrapper, &iargs, 0B);
              sp.228 = sp;
              sp = sp.228 + 8;
              *sp.228 = ins;
              <D.37413>:
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.37331>;
        <D.37328>:
        if (is_instance != 0) goto <D.37422>; else goto <D.37423>;
        <D.37422>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 7) goto <D.37424>; else goto <D.37425>;
        <D.37424>:
        {
          struct MonoInst * var;

          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          D.37427 = (unsigned int) D.32139;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.37427 < D.32058) goto <D.37428>; else goto <D.37429>;
          <D.37428>:
          D.32061 = cfg->vreg_to_inst;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          D.37430 = (long unsigned int) D.32139;
          D.37431 = D.37430 * 8;
          D.37432 = D.32061 + D.37431;
          iftmp.229 = *D.37432;
          goto <D.37433>;
          <D.37429>:
          iftmp.229 = 0B;
          <D.37433>:
          var = iftmp.229;
          if (var == 0B) goto <D.37434>; else goto <D.37435>;
          <D.37434>:
          klass.157 = klass;
          D.35726 = &klass.157->byval_arg;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          var = mono_compile_create_var_for_vreg (cfg, D.35726, 329, D.32139);
          goto <D.37436>;
          <D.37435>:
          D.37437 = var->klass;
          klass.157 = klass;
          D.37438 = D.37437 != klass.157;
          D.37439 = (long int) D.37438;
          D.37440 = __builtin_expect (D.37439, 0);
          if (D.37440 != 0) goto <D.37441>; else goto <D.37442>;
          <D.37441>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10034, "var->klass == klass");
          <D.37442>:
          <D.37436>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 314;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->data.op[0].p = var;
          D.37443 = var->flags;
          D.37444 = D.37443 | 16;
          var->flags = D.37444;
          ins->type = 5;
          D.37437 = var->klass;
          ins->klass = D.37437;
          D.37445 = alloc_dreg (cfg, 5);
          D.37446 = (int) D.37445;
          ins->dreg = D.37446;
          cfg->has_indirection = 1;
          D.31089 = cfg->gsharedvt;
          D.32043 = D.31089 != 0;
          D.32044 = (long int) D.32043;
          D.32045 = __builtin_expect (D.32044, 0);
          if (D.32045 != 0) goto <D.37447>; else goto <D.37448>;
          <D.37447>:
          D.37449 = var->data.op[1].vtype;
          D.37450 = mini_is_gsharedvt_variable_type (cfg, D.37449);
          if (D.37450 != 0) goto <D.37451>; else goto <D.37452>;
          <D.37451>:
          handle_gsharedvt_ldaddr (cfg);
          <D.37452>:
          <D.37448>:
          if (0 != 0) goto <D.37453>; else goto <D.37454>;
          <D.37453>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.37456 = var->dreg;
            D.37457 = D.37456 + 1;
            D.37458 = (unsigned int) D.37457;
            D.32058 = cfg->vreg_to_inst_len;
            if (D.37458 < D.32058) goto <D.37459>; else goto <D.37460>;
            <D.37459>:
            D.32061 = cfg->vreg_to_inst;
            D.37456 = var->dreg;
            D.37461 = (sizetype) D.37456;
            D.37462 = D.37461 + 1;
            D.37463 = D.37462 * 8;
            D.37464 = D.32061 + D.37463;
            iftmp.230 = *D.37464;
            goto <D.37465>;
            <D.37460>:
            iftmp.230 = 0B;
            <D.37465>:
            var1 = iftmp.230;
            D.37456 = var->dreg;
            D.37467 = D.37456 + 2;
            D.37468 = (unsigned int) D.37467;
            D.32058 = cfg->vreg_to_inst_len;
            if (D.37468 < D.32058) goto <D.37469>; else goto <D.37470>;
            <D.37469>:
            D.32061 = cfg->vreg_to_inst;
            D.37456 = var->dreg;
            D.37461 = (sizetype) D.37456;
            D.37471 = D.37461 + 2;
            D.37472 = D.37471 * 8;
            D.37473 = D.32061 + D.37472;
            iftmp.231 = *D.37473;
            goto <D.37474>;
            <D.37470>:
            iftmp.231 = 0B;
            <D.37474>:
            var2 = iftmp.231;
            D.37475 = var1 == 0B;
            D.37476 = (long int) D.37475;
            D.37477 = __builtin_expect (D.37476, 0);
            if (D.37477 != 0) goto <D.37478>; else goto <D.37479>;
            <D.37478>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10036, "var1");
            <D.37479>:
            D.37480 = var2 == 0B;
            D.37481 = (long int) D.37480;
            D.37482 = __builtin_expect (D.37481, 0);
            if (D.37482 != 0) goto <D.37483>; else goto <D.37484>;
            <D.37483>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10036, "var2");
            <D.37484>:
            D.37485 = var1->flags;
            D.37486 = D.37485 | 16;
            var1->flags = D.37486;
            D.37487 = var2->flags;
            D.37488 = D.37487 | 16;
            var2->flags = D.37488;
          }
          <D.37454>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37489>; else goto <D.37490>;
          <D.37489>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.37491>;
          <D.37490>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37491>:
          *sp = ins;
        }
        <D.37425>:
        if (op == 124) goto <D.37492>; else goto <D.37493>;
        <D.37492>:
        D.37494 = is_magic_tls_access (field);
        if (D.37494 != 0) goto <D.37495>; else goto <D.37496>;
        <D.37495>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37497>; else goto <D.37498>;
        <D.37497>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        D.37499 = mono_opcode_name (D.31839);
        D.37500 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.37499, "method-to-ir.c", 10042);
        cfg->exception_message = D.37500;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.37501>; else goto <D.37502>;
        <D.37501>:
        D.32639 = cfg->exception_message;
        printf ("%s\n", D.32639);
        <D.37502>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37498>:
        ins = *sp;
        sp.232 = sp;
        sp = sp.232 + 8;
        D.37504 = create_magic_tls_access (cfg, field, &cached_tls_addr, ins);
        *sp.232 = D.37504;
        goto <D.37505>;
        <D.37496>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 6) goto <D.37506>; else goto <D.37507>;
        <D.37506>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.37508 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37508;
          inst->prev = 0B;
          D.37509 = inst->prev;
          inst->next = D.37509;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37510 = inst->sreg3;
          inst->sreg2 = D.37510;
          D.37511 = inst->sreg2;
          inst->sreg1 = D.37511;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = -1;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          inst->sreg1 = D.32139;
          inst->data.op[1].const_val = 0;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37512>; else goto <D.37513>;
          <D.37512>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.37514>;
          <D.37513>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37514>:
        }
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.37515 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37515;
          inst->prev = 0B;
          D.37516 = inst->prev;
          inst->next = D.37516;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37517 = inst->sreg3;
          inst->sreg2 = D.37517;
          D.37518 = inst->sreg2;
          inst->sreg1 = D.37518;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->data.op[1].p = "NullReferenceException";
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37519>; else goto <D.37520>;
          <D.37519>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.37521>;
          <D.37520>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37521>:
        }
        <D.37507>:
        D.37522 = alloc_ireg_mp (cfg);
        dreg = (int) D.37522;
        klass.157 = klass;
        D.37523 = mini_is_gsharedvt_klass (cfg, klass.157);
        if (D.37523 != 0) goto <D.37524>; else goto <D.37525>;
        <D.37524>:
        {
          struct MonoInst * offset_ins;

          offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 479;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->dreg = dreg;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          ins->sreg1 = D.32139;
          D.37526 = offset_ins->dreg;
          ins->sreg2 = D.37526;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37527>; else goto <D.37528>;
          <D.37527>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.37529>;
          <D.37528>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37529>:
        }
        goto <D.37530>;
        <D.37525>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 538;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = dreg;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        ins->sreg1 = D.32139;
        D.37302 = (long int) foffset;
        ins->data.op[1].const_val = D.37302;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.37531>; else goto <D.37532>;
        <D.37531>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.37533>;
        <D.37532>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.37533>:
        <D.37530>:
        D.37145 = field->type;
        D.37534 = mono_class_from_mono_type (D.37145);
        ins->klass = D.37534;
        ins->type = 5;
        sp.233 = sp;
        sp = sp.233 + 8;
        *sp.233 = ins;
        <D.37505>:
        goto <D.37536>;
        <D.37493>:
        {
          struct MonoInst * load;

          D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.31587 = D.30929 & 64;
          if (D.31587 != 0) goto <D.37537>; else goto <D.37538>;
          <D.37537>:
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37539 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37539;
            inst->prev = 0B;
            D.37540 = inst->prev;
            inst->next = D.37540;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37541 = inst->sreg3;
            inst->sreg2 = D.37541;
            D.37542 = inst->sreg2;
            inst->sreg1 = D.37542;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = -1;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            inst->sreg1 = D.32139;
            inst->data.op[1].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37543>; else goto <D.37544>;
            <D.37543>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37545>;
            <D.37544>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37545>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37546 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37546;
            inst->prev = 0B;
            D.37547 = inst->prev;
            inst->next = D.37547;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37548 = inst->sreg3;
            inst->sreg2 = D.37548;
            D.37549 = inst->sreg2;
            inst->sreg1 = D.37549;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->data.op[1].p = "NullReferenceException";
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37550>; else goto <D.37551>;
            <D.37550>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37552>;
            <D.37551>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37552>:
          }
          goto <D.37553>;
          <D.37538>:
          <D.37553>:
          klass.157 = klass;
          D.37554 = mini_is_gsharedvt_klass (cfg, klass.157);
          if (D.37554 != 0) goto <D.37555>; else goto <D.37556>;
          <D.37555>:
          {
            struct MonoInst * offset_ins;

            offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
            D.37557 = alloc_ireg_mp (cfg);
            dreg = (int) D.37557;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = dreg;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ins->sreg1 = D.32139;
            D.37558 = offset_ins->dreg;
            ins->sreg2 = D.37558;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37559>; else goto <D.37560>;
            <D.37559>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37561>;
            <D.37560>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37561>:
            D.30941 = cfg->mempool;
            load = mono_mempool_alloc (D.30941, 80);
            load->data.op[1].const_val = 0;
            D.37562 = load->data.op[1].const_val;
            load->data.op[0].const_val = D.37562;
            load->prev = 0B;
            D.37563 = load->prev;
            load->next = D.37563;
            D.37145 = field->type;
            D.37564 = mono_type_to_load_membase (cfg, D.37145);
            D.37565 = (short unsigned int) D.37564;
            load->opcode = D.37565;
            load->flags = 0;
            load->type = 0;
            load->dreg = -1;
            load->sreg3 = -1;
            D.37566 = load->sreg3;
            load->sreg2 = D.37566;
            D.37567 = load->sreg2;
            load->sreg1 = D.37567;
            D.31162 = cfg->ip;
            load->cil_code = D.31162;
            load->dreg = 0;
            load->sreg1 = dreg;
            load->data.op[0].const_val = 0;
            load->type = 1;
            D.37145 = field->type;
            type_to_eval_stack_type (cfg, D.37145, load);
            D.37568 = load->type;
            D.37569 = (<unnamed type>) D.37568;
            D.37570 = alloc_dreg (cfg, D.37569);
            D.37571 = (int) D.37570;
            load->dreg = D.37571;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37572>; else goto <D.37573>;
            <D.37572>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = load;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            load->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = load;
            goto <D.37574>;
            <D.37573>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = load;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37574>:
          }
          goto <D.37575>;
          <D.37556>:
          D.30941 = cfg->mempool;
          load = mono_mempool_alloc (D.30941, 80);
          load->data.op[1].const_val = 0;
          D.37562 = load->data.op[1].const_val;
          load->data.op[0].const_val = D.37562;
          load->prev = 0B;
          D.37563 = load->prev;
          load->next = D.37563;
          D.37145 = field->type;
          D.37576 = mono_type_to_load_membase (cfg, D.37145);
          D.37577 = (short unsigned int) D.37576;
          load->opcode = D.37577;
          load->flags = 0;
          load->type = 0;
          load->dreg = -1;
          load->sreg3 = -1;
          D.37566 = load->sreg3;
          load->sreg2 = D.37566;
          D.37567 = load->sreg2;
          load->sreg1 = D.37567;
          D.31162 = cfg->ip;
          load->cil_code = D.31162;
          load->dreg = 0;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          load->sreg1 = D.32139;
          D.37302 = (long int) foffset;
          load->data.op[0].const_val = D.37302;
          load->type = 1;
          D.37145 = field->type;
          type_to_eval_stack_type (cfg, D.37145, load);
          D.37568 = load->type;
          D.37569 = (<unnamed type>) D.37568;
          D.37578 = alloc_dreg (cfg, D.37569);
          D.37579 = (int) D.37578;
          load->dreg = D.37579;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37580>; else goto <D.37581>;
          <D.37580>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = load;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          load->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = load;
          goto <D.37582>;
          <D.37581>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = load;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37582>:
          <D.37575>:
          D.37583 = load->flags;
          D.35267 = (unsigned char) ins_flag;
          D.37584 = D.37583 | D.35267;
          load->flags = D.37584;
          D.31957 = *sp;
          D.33692 = D.31957->opcode;
          if (D.33692 != 314) goto <D.37585>; else goto <D.37586>;
          <D.37585>:
          D.37583 = load->flags;
          D.37587 = D.37583 | 32;
          load->flags = D.37587;
          <D.37586>:
          sp.234 = sp;
          sp = sp.234 + 8;
          *sp.234 = load;
        }
        <D.37536>:
        <D.37423>:
        <D.37331>:
        if (is_instance != 0) goto <D.37589>; else goto <D.37590>;
        <D.37589>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27857>;
        <D.37590>:
        klass.157 = klass;
        context_used = mini_class_check_context_used (cfg, klass.157);
        ftype = mono_field_get_type (field);
        D.37591 = ftype->attrs;
        D.37592 = (int) D.37591;
        D.37593 = D.37592 & 64;
        if (D.37593 != 0) goto <D.37594>; else goto <D.37595>;
        <D.37594>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.37596>; else goto <D.37597>;
        <D.37596>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.37598>; else goto <D.37599>;
        <D.37598>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37599>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37597>:
        D.37600 = mini_get_debug_options ();
        D.37601 = D.37600->break_on_unverified;
        if (D.37601 != 0) goto <D.37602>; else goto unverified;
        <D.37602>:
        raise (5);
        <D.37595>:
        if (context_used == 0) goto <D.37603>; else goto <D.37604>;
        <D.37603>:
        D.31334 = cfg->opt;
        D.31335 = D.31334 & 512;
        if (D.31335 == 0) goto <D.37605>; else goto <D.37606>;
        <D.37605>:
        D.30966 = cfg->domain;
        klass.157 = klass;
        mono_class_vtable (D.30966, klass.157);
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.37607>; else goto <D.37609>;
        <D.37609>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.37607>; else goto <D.37608>;
        <D.37607>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.37610 = mini_get_debug_options ();
        D.37611 = D.37610->break_on_unverified;
        if (D.37611 != 0) goto <D.37612>; else goto load_error;
        <D.37612>:
        raise (5);
        <D.37608>:
        <D.37606>:
        <D.37604>:
        {
          int ret;

          D.30966 = cfg->domain;
          D.37613 = &D.30966->lock.mutex;
          ret = pthread_mutex_lock (D.37613);
          if (ret != 0) goto <D.37614>; else goto <D.37615>;
          <D.37614>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.37615>:
          D.37616 = ret != 0;
          D.37617 = (long int) D.37616;
          D.37618 = __builtin_expect (D.37617, 0);
          if (D.37618 != 0) goto <D.37619>; else goto <D.37620>;
          <D.37619>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10119, "ret == 0");
          <D.37620>:
        }
        D.30966 = cfg->domain;
        D.37621 = D.30966->special_static_fields;
        if (D.37621 != 0B) goto <D.37622>; else goto <D.37623>;
        <D.37622>:
        D.30966 = cfg->domain;
        D.37621 = D.30966->special_static_fields;
        addr = monoeg_g_hash_table_lookup (D.37621, field);
        <D.37623>:
        {
          int ret;

          D.30966 = cfg->domain;
          D.37613 = &D.30966->lock.mutex;
          ret = pthread_mutex_unlock (D.37613);
          if (ret != 0) goto <D.37624>; else goto <D.37625>;
          <D.37624>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.37625>:
          D.37626 = ret != 0;
          D.37627 = (long int) D.37626;
          D.37628 = __builtin_expect (D.37627, 0);
          if (D.37628 != 0) goto <D.37629>; else goto <D.37630>;
          <D.37629>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10122, "ret == 0");
          <D.37630>:
        }
        is_special_static = mono_class_field_is_special_static (field);
        if (is_special_static != 0) goto <D.37633>; else goto <D.37631>;
        <D.37633>:
        addr.235 = (long unsigned int) addr;
        D.37635 = addr.235 & 2147483648;
        if (D.37635 == 0) goto <D.37636>; else goto <D.37631>;
        <D.37636>:
        thread_ins = mono_get_thread_intrinsic (cfg);
        goto <D.37632>;
        <D.37631>:
        thread_ins = 0B;
        <D.37632>:
        if (is_special_static != 0) goto <D.37639>; else goto <D.37637>;
        <D.37639>:
        addr.235 = (long unsigned int) addr;
        D.37635 = addr.235 & 2147483648;
        if (D.37635 == 0) goto <D.37640>; else goto <D.37637>;
        <D.37640>:
        if (thread_ins != 0B) goto <D.37641>; else goto <D.37637>;
        <D.37641>:
        D.31334 = cfg->opt;
        D.31335 = D.31334 & 512;
        if (D.31335 == 0) goto <D.37642>; else goto <D.37637>;
        <D.37642>:
        if (context_used == 0) goto <D.37643>; else goto <D.37637>;
        <D.37643>:
        {
          guint32 offset;
          int idx;
          int static_data_reg;
          int array_reg;
          int dreg;

          D.31089 = cfg->gsharedvt;
          if (D.31089 != 0) goto <D.37644>; else goto <D.37645>;
          <D.37644>:
          D.30878 = method->klass;
          D.32629 = D.30878->name_space;
          D.30878 = method->klass;
          D.32630 = D.30878->name;
          D.32631 = method->name;
          D.32632 = method->signature;
          D.32633 = D.32632->param_count;
          D.32634 = (int) D.32633;
          D.37646 = mono_opcode_name (op);
          D.37647 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.37646, "method-to-ir.c", 10141);
          cfg->exception_message = D.37647;
          D.31021 = cfg->verbose_level;
          if (D.31021 > 1) goto <D.37648>; else goto <D.37649>;
          <D.37648>:
          D.32639 = cfg->exception_message;
          printf ("%s\n", D.32639);
          <D.37649>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.37645>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37650>; else goto <D.37651>;
          <D.37650>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = thread_ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          thread_ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = thread_ins;
          goto <D.37652>;
          <D.37651>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = thread_ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37652>:
          D.37653 = alloc_ireg (cfg);
          static_data_reg = (int) D.37653;
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37654 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37654;
            inst->prev = 0B;
            D.37655 = inst->prev;
            inst->next = D.37655;
            inst->opcode = 388;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37656 = inst->sreg3;
            inst->sreg2 = D.37656;
            D.37657 = inst->sreg2;
            inst->sreg1 = D.37657;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = static_data_reg;
            D.37658 = thread_ins->dreg;
            inst->sreg1 = D.37658;
            inst->data.op[0].const_val = 96;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37659>; else goto <D.37660>;
            <D.37659>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37661>;
            <D.37660>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37661>:
          }
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.37662>; else goto <D.37663>;
          <D.37662>:
          {
            int offset_reg;
            int offset2_reg;
            int idx_reg;

            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.37665>; else goto <D.37666>;
            <D.37665>:
            iftmp.236 = 734;
            goto <D.37667>;
            <D.37666>:
            iftmp.236 = 363;
            <D.37667>:
            ins->opcode = iftmp.236;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.37668>; else goto <D.37669>;
            <D.37668>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.37670 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.37670;
              group->prev = 0B;
              D.37671 = group->prev;
              group->next = D.37671;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.37672 = group->sreg3;
              group->sreg2 = D.37672;
              D.37673 = group->sreg2;
              group->sreg1 = D.37673;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              group->data.op[0].src = field;
              group->data.op[1].src = 16B;
              D.37674 = got_loc->dreg;
              ins->sreg1 = D.37674;
              ins->data.op[1].p = group;
            }
            goto <D.37675>;
            <D.37669>:
            ins->data.op[0].p = field;
            ins->data.op[1].src = 16B;
            <D.37675>:
            ins->type = 3;
            D.37676 = alloc_dreg (cfg, 3);
            D.37677 = (int) D.37676;
            ins->dreg = D.37677;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37678>; else goto <D.37679>;
            <D.37678>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37680>;
            <D.37679>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37680>:
            offset_reg = ins->dreg;
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37681 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37681;
              inst->prev = 0B;
              D.37682 = inst->prev;
              inst->next = D.37682;
              inst->opcode = 632;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37683 = inst->sreg3;
              inst->sreg2 = D.37683;
              D.37684 = inst->sreg2;
              inst->sreg1 = D.37684;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = offset_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 2147483647;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37685>; else goto <D.37686>;
              <D.37685>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37687>;
              <D.37686>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37687>:
            }
            D.37688 = alloc_ireg (cfg);
            idx_reg = (int) D.37688;
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37689 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37689;
              inst->prev = 0B;
              D.37690 = inst->prev;
              inst->next = D.37690;
              inst->opcode = 636;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37691 = inst->sreg3;
              inst->sreg2 = D.37691;
              D.37692 = inst->sreg2;
              inst->sreg1 = D.37692;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = idx_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 24;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37693>; else goto <D.37694>;
              <D.37693>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37695>;
              <D.37694>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37695>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37696 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37696;
              inst->prev = 0B;
              D.37697 = inst->prev;
              inst->next = D.37697;
              inst->opcode = 626;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37698 = inst->sreg3;
              inst->sreg2 = D.37698;
              D.37699 = inst->sreg2;
              inst->sreg1 = D.37699;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = idx_reg;
              inst->sreg1 = idx_reg;
              inst->data.op[1].const_val = 1;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37700>; else goto <D.37701>;
              <D.37700>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37702>;
              <D.37701>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37702>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37703 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37703;
              inst->prev = 0B;
              D.37704 = inst->prev;
              inst->next = D.37704;
              inst->opcode = 635;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37705 = inst->sreg3;
              inst->sreg2 = D.37705;
              D.37706 = inst->sreg2;
              inst->sreg1 = D.37706;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = idx_reg;
              inst->sreg1 = idx_reg;
              inst->data.op[1].const_val = 3;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37707>; else goto <D.37708>;
              <D.37707>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37709>;
              <D.37708>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37709>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37710 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37710;
              inst->prev = 0B;
              D.37711 = inst->prev;
              inst->next = D.37711;
              inst->opcode = 479;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37712 = inst->sreg3;
              inst->sreg2 = D.37712;
              D.37713 = inst->sreg2;
              inst->sreg1 = D.37713;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = static_data_reg;
              inst->sreg1 = static_data_reg;
              inst->sreg2 = idx_reg;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37714>; else goto <D.37715>;
              <D.37714>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37716>;
              <D.37715>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37716>:
            }
            D.37717 = alloc_ireg (cfg);
            array_reg = (int) D.37717;
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37718 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37718;
              inst->prev = 0B;
              D.37719 = inst->prev;
              inst->next = D.37719;
              inst->opcode = 388;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37720 = inst->sreg3;
              inst->sreg2 = D.37720;
              D.37721 = inst->sreg2;
              inst->sreg1 = D.37721;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = array_reg;
              inst->sreg1 = static_data_reg;
              inst->data.op[0].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37722>; else goto <D.37723>;
              <D.37722>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37724>;
              <D.37723>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37724>:
            }
            D.37725 = alloc_ireg (cfg);
            offset2_reg = (int) D.37725;
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.37726 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37726;
              inst->prev = 0B;
              D.37727 = inst->prev;
              inst->next = D.37727;
              inst->opcode = 632;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37728 = inst->sreg3;
              inst->sreg2 = D.37728;
              D.37729 = inst->sreg2;
              inst->sreg1 = D.37729;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = offset2_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 16777215;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37730>; else goto <D.37731>;
              <D.37730>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.37732>;
              <D.37731>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37732>:
            }
            D.37733 = alloc_ireg (cfg);
            dreg = (int) D.37733;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = dreg;
            ins->sreg1 = array_reg;
            ins->sreg2 = offset2_reg;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37734>; else goto <D.37735>;
            <D.37734>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37736>;
            <D.37735>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37736>:
          }
          goto <D.37737>;
          <D.37663>:
          addr.237 = (long int) addr;
          D.37739 = (unsigned int) addr.237;
          offset = D.37739 & 2147483647;
          D.37740 = offset >> 24;
          D.37741 = D.37740 + 4294967295;
          idx = (int) D.37741;
          D.37742 = alloc_ireg (cfg);
          array_reg = (int) D.37742;
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.37743 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37743;
            inst->prev = 0B;
            D.37744 = inst->prev;
            inst->next = D.37744;
            inst->opcode = 388;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37745 = inst->sreg3;
            inst->sreg2 = D.37745;
            D.37746 = inst->sreg2;
            inst->sreg1 = D.37746;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = array_reg;
            inst->sreg1 = static_data_reg;
            D.37747 = (long unsigned int) idx;
            D.37748 = D.37747 * 8;
            D.37749 = (long int) D.37748;
            inst->data.op[0].const_val = D.37749;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37750>; else goto <D.37751>;
            <D.37750>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.37752>;
            <D.37751>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37752>:
          }
          D.37753 = alloc_ireg (cfg);
          dreg = (int) D.37753;
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 429;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->dreg = dreg;
          ins->sreg1 = array_reg;
          D.37754 = (long int) offset;
          D.37755 = D.37754 & 16777215;
          ins->data.op[1].const_val = D.37755;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37756>; else goto <D.37757>;
          <D.37756>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.37758>;
          <D.37757>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37758>:
          <D.37737>:
        }
        goto <D.37638>;
        <D.37637>:
        D.31334 = cfg->opt;
        D.31335 = D.31334 & 512;
        if (D.31335 != 0) goto <D.37759>; else goto <D.37763>;
        <D.37763>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.37764>; else goto <D.37760>;
        <D.37764>:
        if (is_special_static != 0) goto <D.37759>; else goto <D.37760>;
        <D.37760>:
        if (context_used != 0) goto <D.37765>; else goto <D.37761>;
        <D.37765>:
        if (is_special_static != 0) goto <D.37759>; else goto <D.37761>;
        <D.37759>:
        {
          struct MonoInst * iargs[2];

          try
            {
              klass.218 = field->parent;
              D.37766 = klass.218 == 0B;
              D.37767 = (long int) D.37766;
              D.37768 = __builtin_expect (D.37767, 0);
              if (D.37768 != 0) goto <D.37769>; else goto <D.37770>;
              <D.37769>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10182, "field->parent");
              <D.37770>:
              D.31334 = cfg->opt;
              D.31335 = D.31334 & 512;
              if (D.31335 != 0) goto <D.37771>; else goto <D.37774>;
              <D.37774>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37771>; else goto <D.37772>;
              <D.37771>:
              {
                struct MonoInst * __domain_var;

                __domain_var = mono_get_domainvar (cfg);
                D.30941 = cfg->mempool;
                D.37775 = mono_mempool_alloc (D.30941, 80);
                iargs[0] = D.37775;
                D.37776 = iargs[0];
                D.37776 = iargs[0];
                D.37776->data.op[1].const_val = 0;
                D.37777 = D.37776->data.op[1].const_val;
                D.37776->data.op[0].const_val = D.37777;
                D.37776 = iargs[0];
                D.37776 = iargs[0];
                D.37776->prev = 0B;
                D.37778 = D.37776->prev;
                D.37776->next = D.37778;
                D.37776 = iargs[0];
                D.37776->opcode = 424;
                D.37776 = iargs[0];
                D.37776->flags = 0;
                D.37776 = iargs[0];
                D.37776->type = 0;
                D.37776 = iargs[0];
                D.37776->dreg = -1;
                D.37776 = iargs[0];
                D.37776 = iargs[0];
                D.37776 = iargs[0];
                D.37776->sreg3 = -1;
                D.37779 = D.37776->sreg3;
                D.37776->sreg2 = D.37779;
                D.37780 = D.37776->sreg2;
                D.37776->sreg1 = D.37780;
                D.37776 = iargs[0];
                D.31162 = cfg->ip;
                D.37776->cil_code = D.31162;
                D.37776 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37781 = __domain_var->data.op[0].const_val;
                D.37782 = (long unsigned int) D.37781;
                D.37783 = D.37782 * 8;
                D.37784 = D.31695 + D.37783;
                D.37785 = *D.37784;
                D.37786 = D.37785->data.op[1].vtype;
                D.37787 = mono_type_to_regmove (cfg, D.37786);
                D.37788 = (short unsigned int) D.37787;
                D.37776->opcode = D.37788;
                D.31695 = cfg->varinfo;
                D.37781 = __domain_var->data.op[0].const_val;
                D.37782 = (long unsigned int) D.37781;
                D.37783 = D.37782 * 8;
                D.37784 = D.31695 + D.37783;
                D.37785 = *D.37784;
                D.37786 = D.37785->data.op[1].vtype;
                D.37776 = iargs[0];
                type_to_eval_stack_type (cfg, D.37786, D.37776);
                D.37776 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37781 = __domain_var->data.op[0].const_val;
                D.37782 = (long unsigned int) D.37781;
                D.37783 = D.37782 * 8;
                D.37784 = D.31695 + D.37783;
                D.37785 = *D.37784;
                D.37789 = D.37785->klass;
                D.37776->klass = D.37789;
                D.37776 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37781 = __domain_var->data.op[0].const_val;
                D.37782 = (long unsigned int) D.37781;
                D.37783 = D.37782 * 8;
                D.37784 = D.31695 + D.37783;
                D.37785 = *D.37784;
                D.37790 = D.37785->dreg;
                D.37776->sreg1 = D.37790;
                D.37776 = iargs[0];
                D.37776 = iargs[0];
                D.37791 = D.37776->type;
                D.37792 = (<unnamed type>) D.37791;
                D.37793 = alloc_dreg (cfg, D.37792);
                D.37794 = (int) D.37793;
                D.37776->dreg = D.37794;
                D.37776 = iargs[0];
                D.37795 = D.37776->opcode;
                if (D.37795 == 427) goto <D.37796>; else goto <D.37797>;
                <D.37796>:
                D.37776 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37781 = __domain_var->data.op[0].const_val;
                D.37782 = (long unsigned int) D.37781;
                D.37783 = D.37782 * 8;
                D.37784 = D.31695 + D.37783;
                D.37785 = *D.37784;
                D.37786 = D.37785->data.op[1].vtype;
                D.37798 = mono_class_from_mono_type (D.37786);
                D.37776->klass = D.37798;
                <D.37797>:
              }
              goto <D.37773>;
              <D.37772>:
              D.30941 = cfg->mempool;
              D.37799 = mono_mempool_alloc (D.30941, 80);
              iargs[0] = D.37799;
              D.37776 = iargs[0];
              D.37776 = iargs[0];
              D.37776->data.op[1].const_val = 0;
              D.37777 = D.37776->data.op[1].const_val;
              D.37776->data.op[0].const_val = D.37777;
              D.37776 = iargs[0];
              D.37776 = iargs[0];
              D.37776->prev = 0B;
              D.37778 = D.37776->prev;
              D.37776->next = D.37778;
              D.37776 = iargs[0];
              D.37776->opcode = 363;
              D.37776 = iargs[0];
              D.37776->flags = 0;
              D.37776 = iargs[0];
              D.37776->type = 0;
              D.37776 = iargs[0];
              D.37776->dreg = -1;
              D.37776 = iargs[0];
              D.37776 = iargs[0];
              D.37776 = iargs[0];
              D.37776->sreg3 = -1;
              D.37779 = D.37776->sreg3;
              D.37776->sreg2 = D.37779;
              D.37780 = D.37776->sreg2;
              D.37776->sreg1 = D.37780;
              D.37776 = iargs[0];
              D.31162 = cfg->ip;
              D.37776->cil_code = D.31162;
              D.37776 = iargs[0];
              D.30966 = cfg->domain;
              D.37776->data.op[0].p = D.30966;
              D.37776 = iargs[0];
              D.37776->type = 3;
              D.37776 = iargs[0];
              D.37800 = alloc_dreg (cfg, 3);
              D.37801 = (int) D.37800;
              D.37776->dreg = D.37801;
              <D.37773>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37802>; else goto <D.37803>;
              <D.37802>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37776 = iargs[0];
              D.31191->next = D.37776;
              D.37776 = iargs[0];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37776->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37776 = iargs[0];
              bblock.113->last_ins = D.37776;
              goto <D.37804>;
              <D.37803>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37776 = iargs[0];
              bblock.113->last_ins = D.37776;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37804>:
              if (context_used != 0) goto <D.37805>; else goto <D.37806>;
              <D.37805>:
              D.37807 = emit_get_rgctx_field (cfg, context_used, field, 7);
              iargs[1] = D.37807;
              goto <D.37808>;
              <D.37806>:
              D.30941 = cfg->mempool;
              D.37809 = mono_mempool_alloc (D.30941, 80);
              iargs[1] = D.37809;
              D.37810 = iargs[1];
              D.37810 = iargs[1];
              D.37810->data.op[1].const_val = 0;
              D.37811 = D.37810->data.op[1].const_val;
              D.37810->data.op[0].const_val = D.37811;
              D.37810 = iargs[1];
              D.37810 = iargs[1];
              D.37810->prev = 0B;
              D.37812 = D.37810->prev;
              D.37810->next = D.37812;
              D.37810 = iargs[1];
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37814>; else goto <D.37815>;
              <D.37814>:
              iftmp.238 = 734;
              goto <D.37816>;
              <D.37815>:
              iftmp.238 = 363;
              <D.37816>:
              D.37810->opcode = iftmp.238;
              D.37810 = iargs[1];
              D.37810->flags = 0;
              D.37810 = iargs[1];
              D.37810->type = 0;
              D.37810 = iargs[1];
              D.37810->dreg = -1;
              D.37810 = iargs[1];
              D.37810 = iargs[1];
              D.37810 = iargs[1];
              D.37810->sreg3 = -1;
              D.37817 = D.37810->sreg3;
              D.37810->sreg2 = D.37817;
              D.37818 = D.37810->sreg2;
              D.37810->sreg1 = D.37818;
              D.37810 = iargs[1];
              D.31162 = cfg->ip;
              D.37810->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37819>; else goto <D.37820>;
              <D.37819>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37821 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37821;
                group->prev = 0B;
                D.37822 = group->prev;
                group->next = D.37822;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37823 = group->sreg3;
                group->sreg2 = D.37823;
                D.37824 = group->sreg2;
                group->sreg1 = D.37824;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = field;
                group->data.op[1].src = 13B;
                D.37810 = iargs[1];
                D.37825 = got_loc->dreg;
                D.37810->sreg1 = D.37825;
                D.37810 = iargs[1];
                D.37810->data.op[1].p = group;
              }
              goto <D.37826>;
              <D.37820>:
              D.37810 = iargs[1];
              D.37810->data.op[0].p = field;
              D.37810 = iargs[1];
              D.37810->data.op[1].src = 13B;
              <D.37826>:
              D.37810 = iargs[1];
              D.37810->type = 3;
              D.37810 = iargs[1];
              D.37827 = alloc_dreg (cfg, 3);
              D.37828 = (int) D.37827;
              D.37810->dreg = D.37828;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37829>; else goto <D.37830>;
              <D.37829>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37810 = iargs[1];
              D.31191->next = D.37810;
              D.37810 = iargs[1];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37810->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37810 = iargs[1];
              bblock.113->last_ins = D.37810;
              goto <D.37831>;
              <D.37830>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37810 = iargs[1];
              bblock.113->last_ins = D.37810;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37831>:
              <D.37808>:
              ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, &iargs);
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.37762>;
        <D.37761>:
        if (context_used != 0) goto <D.37832>; else goto <D.37833>;
        <D.37832>:
        {
          struct MonoInst * static_data;

          klass.157 = klass;
          D.37834 = mono_class_needs_cctor_run (klass.157, method);
          if (D.37834 != 0) goto <D.37835>; else goto <D.37836>;
          <D.37835>:
          klass.157 = klass;
          emit_generic_class_init (cfg, klass.157);
          <D.37836>:
          klass.157 = klass;
          static_data = emit_get_rgctx_klass (cfg, context_used, klass.157, 0);
          klass.157 = klass;
          D.37837 = mini_is_gsharedvt_klass (cfg, klass.157);
          if (D.37837 != 0) goto <D.37838>; else goto <D.37839>;
          <D.37838>:
          {
            struct MonoInst * offset_ins;

            offset_ins = emit_get_rgctx_field (cfg, context_used, field, 15);
            D.37840 = alloc_ireg_mp (cfg);
            dreg = (int) D.37840;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = dreg;
            D.37841 = static_data->dreg;
            ins->sreg1 = D.37841;
            D.37842 = offset_ins->dreg;
            ins->sreg2 = D.37842;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37843>; else goto <D.37844>;
            <D.37843>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37845>;
            <D.37844>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37845>:
          }
          goto <D.37846>;
          <D.37839>:
          D.37155 = field->offset;
          if (D.37155 == 0) goto <D.37847>; else goto <D.37848>;
          <D.37847>:
          ins = static_data;
          goto <D.37849>;
          <D.37848>:
          {
            int addr_reg;

            D.37850 = mono_alloc_preg (cfg);
            addr_reg = (int) D.37850;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 538;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->dreg = addr_reg;
            D.37841 = static_data->dreg;
            ins->sreg1 = D.37841;
            D.37155 = field->offset;
            D.37851 = (long int) D.37155;
            ins->data.op[1].const_val = D.37851;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.37852>; else goto <D.37853>;
            <D.37852>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.37854>;
            <D.37853>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.37854>:
          }
          <D.37849>:
          <D.37846>:
        }
        goto <D.37855>;
        <D.37833>:
        D.31334 = cfg->opt;
        D.31335 = D.31334 & 512;
        if (D.31335 != 0) goto <D.37856>; else goto <D.37859>;
        <D.37859>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.37860>; else goto <D.37857>;
        <D.37860>:
        if (addr != 0B) goto <D.37856>; else goto <D.37857>;
        <D.37856>:
        {
          struct MonoInst * iargs[2];

          try
            {
              klass.218 = field->parent;
              D.37766 = klass.218 == 0B;
              D.37767 = (long int) D.37766;
              D.37768 = __builtin_expect (D.37767, 0);
              if (D.37768 != 0) goto <D.37861>; else goto <D.37862>;
              <D.37861>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10226, "field->parent");
              <D.37862>:
              D.31334 = cfg->opt;
              D.31335 = D.31334 & 512;
              if (D.31335 != 0) goto <D.37863>; else goto <D.37866>;
              <D.37866>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37863>; else goto <D.37864>;
              <D.37863>:
              {
                struct MonoInst * __domain_var;

                __domain_var = mono_get_domainvar (cfg);
                D.30941 = cfg->mempool;
                D.37867 = mono_mempool_alloc (D.30941, 80);
                iargs[0] = D.37867;
                D.37868 = iargs[0];
                D.37868 = iargs[0];
                D.37868->data.op[1].const_val = 0;
                D.37869 = D.37868->data.op[1].const_val;
                D.37868->data.op[0].const_val = D.37869;
                D.37868 = iargs[0];
                D.37868 = iargs[0];
                D.37868->prev = 0B;
                D.37870 = D.37868->prev;
                D.37868->next = D.37870;
                D.37868 = iargs[0];
                D.37868->opcode = 424;
                D.37868 = iargs[0];
                D.37868->flags = 0;
                D.37868 = iargs[0];
                D.37868->type = 0;
                D.37868 = iargs[0];
                D.37868->dreg = -1;
                D.37868 = iargs[0];
                D.37868 = iargs[0];
                D.37868 = iargs[0];
                D.37868->sreg3 = -1;
                D.37871 = D.37868->sreg3;
                D.37868->sreg2 = D.37871;
                D.37872 = D.37868->sreg2;
                D.37868->sreg1 = D.37872;
                D.37868 = iargs[0];
                D.31162 = cfg->ip;
                D.37868->cil_code = D.31162;
                D.37868 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37873 = __domain_var->data.op[0].const_val;
                D.37874 = (long unsigned int) D.37873;
                D.37875 = D.37874 * 8;
                D.37876 = D.31695 + D.37875;
                D.37877 = *D.37876;
                D.37878 = D.37877->data.op[1].vtype;
                D.37879 = mono_type_to_regmove (cfg, D.37878);
                D.37880 = (short unsigned int) D.37879;
                D.37868->opcode = D.37880;
                D.31695 = cfg->varinfo;
                D.37873 = __domain_var->data.op[0].const_val;
                D.37874 = (long unsigned int) D.37873;
                D.37875 = D.37874 * 8;
                D.37876 = D.31695 + D.37875;
                D.37877 = *D.37876;
                D.37878 = D.37877->data.op[1].vtype;
                D.37868 = iargs[0];
                type_to_eval_stack_type (cfg, D.37878, D.37868);
                D.37868 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37873 = __domain_var->data.op[0].const_val;
                D.37874 = (long unsigned int) D.37873;
                D.37875 = D.37874 * 8;
                D.37876 = D.31695 + D.37875;
                D.37877 = *D.37876;
                D.37881 = D.37877->klass;
                D.37868->klass = D.37881;
                D.37868 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37873 = __domain_var->data.op[0].const_val;
                D.37874 = (long unsigned int) D.37873;
                D.37875 = D.37874 * 8;
                D.37876 = D.31695 + D.37875;
                D.37877 = *D.37876;
                D.37882 = D.37877->dreg;
                D.37868->sreg1 = D.37882;
                D.37868 = iargs[0];
                D.37868 = iargs[0];
                D.37883 = D.37868->type;
                D.37884 = (<unnamed type>) D.37883;
                D.37885 = alloc_dreg (cfg, D.37884);
                D.37886 = (int) D.37885;
                D.37868->dreg = D.37886;
                D.37868 = iargs[0];
                D.37887 = D.37868->opcode;
                if (D.37887 == 427) goto <D.37888>; else goto <D.37889>;
                <D.37888>:
                D.37868 = iargs[0];
                D.31695 = cfg->varinfo;
                D.37873 = __domain_var->data.op[0].const_val;
                D.37874 = (long unsigned int) D.37873;
                D.37875 = D.37874 * 8;
                D.37876 = D.31695 + D.37875;
                D.37877 = *D.37876;
                D.37878 = D.37877->data.op[1].vtype;
                D.37890 = mono_class_from_mono_type (D.37878);
                D.37868->klass = D.37890;
                <D.37889>:
              }
              goto <D.37865>;
              <D.37864>:
              D.30941 = cfg->mempool;
              D.37891 = mono_mempool_alloc (D.30941, 80);
              iargs[0] = D.37891;
              D.37868 = iargs[0];
              D.37868 = iargs[0];
              D.37868->data.op[1].const_val = 0;
              D.37869 = D.37868->data.op[1].const_val;
              D.37868->data.op[0].const_val = D.37869;
              D.37868 = iargs[0];
              D.37868 = iargs[0];
              D.37868->prev = 0B;
              D.37870 = D.37868->prev;
              D.37868->next = D.37870;
              D.37868 = iargs[0];
              D.37868->opcode = 363;
              D.37868 = iargs[0];
              D.37868->flags = 0;
              D.37868 = iargs[0];
              D.37868->type = 0;
              D.37868 = iargs[0];
              D.37868->dreg = -1;
              D.37868 = iargs[0];
              D.37868 = iargs[0];
              D.37868 = iargs[0];
              D.37868->sreg3 = -1;
              D.37871 = D.37868->sreg3;
              D.37868->sreg2 = D.37871;
              D.37872 = D.37868->sreg2;
              D.37868->sreg1 = D.37872;
              D.37868 = iargs[0];
              D.31162 = cfg->ip;
              D.37868->cil_code = D.31162;
              D.37868 = iargs[0];
              D.30966 = cfg->domain;
              D.37868->data.op[0].p = D.30966;
              D.37868 = iargs[0];
              D.37868->type = 3;
              D.37868 = iargs[0];
              D.37892 = alloc_dreg (cfg, 3);
              D.37893 = (int) D.37892;
              D.37868->dreg = D.37893;
              <D.37865>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37894>; else goto <D.37895>;
              <D.37894>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37868 = iargs[0];
              D.31191->next = D.37868;
              D.37868 = iargs[0];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37868->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37868 = iargs[0];
              bblock.113->last_ins = D.37868;
              goto <D.37896>;
              <D.37895>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37868 = iargs[0];
              bblock.113->last_ins = D.37868;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37896>:
              D.30941 = cfg->mempool;
              D.37897 = mono_mempool_alloc (D.30941, 80);
              iargs[1] = D.37897;
              D.37898 = iargs[1];
              D.37898 = iargs[1];
              D.37898->data.op[1].const_val = 0;
              D.37899 = D.37898->data.op[1].const_val;
              D.37898->data.op[0].const_val = D.37899;
              D.37898 = iargs[1];
              D.37898 = iargs[1];
              D.37898->prev = 0B;
              D.37900 = D.37898->prev;
              D.37898->next = D.37900;
              D.37898 = iargs[1];
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37902>; else goto <D.37903>;
              <D.37902>:
              iftmp.239 = 734;
              goto <D.37904>;
              <D.37903>:
              iftmp.239 = 363;
              <D.37904>:
              D.37898->opcode = iftmp.239;
              D.37898 = iargs[1];
              D.37898->flags = 0;
              D.37898 = iargs[1];
              D.37898->type = 0;
              D.37898 = iargs[1];
              D.37898->dreg = -1;
              D.37898 = iargs[1];
              D.37898 = iargs[1];
              D.37898 = iargs[1];
              D.37898->sreg3 = -1;
              D.37905 = D.37898->sreg3;
              D.37898->sreg2 = D.37905;
              D.37906 = D.37898->sreg2;
              D.37898->sreg1 = D.37906;
              D.37898 = iargs[1];
              D.31162 = cfg->ip;
              D.37898->cil_code = D.31162;
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.37907>; else goto <D.37908>;
              <D.37907>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.37909 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.37909;
                group->prev = 0B;
                D.37910 = group->prev;
                group->next = D.37910;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.37911 = group->sreg3;
                group->sreg2 = D.37911;
                D.37912 = group->sreg2;
                group->sreg1 = D.37912;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = field;
                group->data.op[1].src = 13B;
                D.37898 = iargs[1];
                D.37913 = got_loc->dreg;
                D.37898->sreg1 = D.37913;
                D.37898 = iargs[1];
                D.37898->data.op[1].p = group;
              }
              goto <D.37914>;
              <D.37908>:
              D.37898 = iargs[1];
              D.37898->data.op[0].p = field;
              D.37898 = iargs[1];
              D.37898->data.op[1].src = 13B;
              <D.37914>:
              D.37898 = iargs[1];
              D.37898->type = 3;
              D.37898 = iargs[1];
              D.37915 = alloc_dreg (cfg, 3);
              D.37916 = (int) D.37915;
              D.37898->dreg = D.37916;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.37917>; else goto <D.37918>;
              <D.37917>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37898 = iargs[1];
              D.31191->next = D.37898;
              D.37898 = iargs[1];
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.37898->prev = D.31191;
              bblock.113 = cfg->cbb;
              D.37898 = iargs[1];
              bblock.113->last_ins = D.37898;
              goto <D.37919>;
              <D.37918>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              D.37898 = iargs[1];
              bblock.113->last_ins = D.37898;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.37919>:
              ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, &iargs);
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.37858>;
        <D.37857>:
        {
          struct MonoVTable * vtable;

          vtable = 0B;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 == 0) goto <D.37920>; else goto <D.37921>;
          <D.37920>:
          D.30966 = cfg->domain;
          klass.157 = klass;
          vtable = mono_class_vtable (D.30966, klass.157);
          <D.37921>:
          klass.157 = klass;
          if (klass.157 == 0B) goto <D.37922>; else goto <D.37924>;
          <D.37924>:
          klass.157 = klass;
          D.35652 = klass.157->exception_type;
          if (D.35652 != 0) goto <D.37922>; else goto <D.37923>;
          <D.37922>:
          klass.157 = klass;
          cfg->exception_ptr = klass.157;
          D.37925 = mini_get_debug_options ();
          D.37926 = D.37925->break_on_unverified;
          if (D.37926 != 0) goto <D.37927>; else goto load_error;
          <D.37927>:
          raise (5);
          <D.37923>:
          if (addr == 0B) goto <D.37928>; else goto <D.37929>;
          <D.37928>:
          klass.157 = klass;
          D.37930 = mini_field_access_needs_cctor_run (cfg, method, klass.157, vtable);
          if (D.37930 != 0) goto <D.37931>; else goto <D.37932>;
          <D.37931>:
          klass.157 = klass;
          D.37933 = monoeg_g_slist_find (class_inits, klass.157);
          if (D.37933 == 0B) goto <D.37934>; else goto <D.37935>;
          <D.37934>:
          klass.157 = klass;
          helper_sig_class_init_trampoline.175 = helper_sig_class_init_trampoline;
          mono_emit_abs_call (cfg, 15, klass.157, helper_sig_class_init_trampoline.175, 0B);
          D.31021 = cfg->verbose_level;
          if (D.31021 > 2) goto <D.37936>; else goto <D.37937>;
          <D.37936>:
          klass.157 = klass;
          D.37938 = klass.157->name_space;
          klass.157 = klass;
          D.37939 = klass.157->name;
          D.37940 = mono_field_get_name (field);
          printf ("class %s.%s needs init call for %s\n", D.37938, D.37939, D.37940);
          <D.37937>:
          klass.157 = klass;
          class_inits = monoeg_g_slist_prepend (class_inits, klass.157);
          <D.37935>:
          goto <D.37941>;
          <D.37932>:
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.37942 = D.31336 & 68719476736;
          if (D.37942 != 0) goto <D.37943>; else goto <D.37944>;
          <D.37943>:
          {
            struct MonoException * ex;

            D.37945 = vtable == 0B;
            D.37946 = (long int) D.37945;
            D.37947 = __builtin_expect (D.37946, 0);
            if (D.37947 != 0) goto <D.37948>; else goto <D.37949>;
            <D.37948>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10251, "vtable");
            <D.37949>:
            D.37950 = BIT_FIELD_REF <*vtable, 64, 320>;
            D.37951 = D.37950 & 33554432;
            if (D.37951 == 0) goto <D.37952>; else goto <D.37953>;
            <D.37952>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.37954>; else goto <D.37955>;
            <D.37954>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.37956>; else goto <D.37957>;
            <D.37956>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.37958>; else goto <D.37959>;
            <D.37958>:
            printf ("inline failed: %s\n", "class init");
            <D.37959>:
            goto inline_failure;
            <D.37957>:
            <D.37955>:
            <D.37953>:
            ex = mono_runtime_class_init_full (vtable, 0);
            if (ex != 0B) goto <D.37960>; else goto <D.37961>;
            <D.37960>:
            set_exception_object (cfg, ex);
            goto exception_exit;
            <D.37961>:
          }
          <D.37944>:
          <D.37941>:
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.37962>; else goto <D.37963>;
          <D.37962>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.37965>; else goto <D.37966>;
          <D.37965>:
          iftmp.240 = 734;
          goto <D.37967>;
          <D.37966>:
          iftmp.240 = 363;
          <D.37967>:
          ins->opcode = iftmp.240;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 != 0) goto <D.37968>; else goto <D.37969>;
          <D.37968>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.30941 = cfg->mempool;
            group = mono_mempool_alloc (D.30941, 80);
            group->data.op[1].const_val = 0;
            D.37970 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.37970;
            group->prev = 0B;
            D.37971 = group->prev;
            group->next = D.37971;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.37972 = group->sreg3;
            group->sreg2 = D.37972;
            D.37973 = group->sreg2;
            group->sreg1 = D.37973;
            D.31162 = cfg->ip;
            group->cil_code = D.31162;
            group->data.op[0].src = field;
            group->data.op[1].src = 16B;
            D.37974 = got_loc->dreg;
            ins->sreg1 = D.37974;
            ins->data.op[1].p = group;
          }
          goto <D.37975>;
          <D.37969>:
          ins->data.op[0].p = field;
          ins->data.op[1].src = 16B;
          <D.37975>:
          ins->type = 3;
          D.37976 = alloc_dreg (cfg, 3);
          D.37977 = (int) D.37976;
          ins->dreg = D.37977;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37978>; else goto <D.37979>;
          <D.37978>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.37980>;
          <D.37979>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37980>:
          goto <D.37981>;
          <D.37963>:
          D.37945 = vtable == 0B;
          D.37946 = (long int) D.37945;
          D.37947 = __builtin_expect (D.37946, 0);
          if (D.37947 != 0) goto <D.37982>; else goto <D.37983>;
          <D.37982>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10264, "vtable");
          <D.37983>:
          D.37984 = mono_vtable_get_static_field_data (vtable);
          D.37155 = field->offset;
          D.37985 = (sizetype) D.37155;
          addr = D.37984 + D.37985;
          D.37986 = addr == 0B;
          D.37987 = (long int) D.37986;
          D.37988 = __builtin_expect (D.37987, 0);
          if (D.37988 != 0) goto <D.37989>; else goto <D.37990>;
          <D.37989>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10266, "addr");
          <D.37990>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 363;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->data.op[0].p = addr;
          ins->type = 3;
          D.37991 = alloc_dreg (cfg, 3);
          D.37992 = (int) D.37991;
          ins->dreg = D.37992;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.37993>; else goto <D.37994>;
          <D.37993>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.37995>;
          <D.37994>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.37995>:
          <D.37981>:
          goto <D.37996>;
          <D.37929>:
          {
            struct MonoInst * iargs[1];

            try
              {
                D.30941 = cfg->mempool;
                D.37997 = mono_mempool_alloc (D.30941, 80);
                iargs[0] = D.37997;
                D.37998 = iargs[0];
                D.37998 = iargs[0];
                D.37998->data.op[1].const_val = 0;
                D.37999 = D.37998->data.op[1].const_val;
                D.37998->data.op[0].const_val = D.37999;
                D.37998 = iargs[0];
                D.37998 = iargs[0];
                D.37998->prev = 0B;
                D.38000 = D.37998->prev;
                D.37998->next = D.38000;
                D.37998 = iargs[0];
                D.37998->opcode = 362;
                D.37998 = iargs[0];
                D.37998->flags = 0;
                D.37998 = iargs[0];
                D.37998->type = 0;
                D.37998 = iargs[0];
                D.37998->dreg = -1;
                D.37998 = iargs[0];
                D.37998 = iargs[0];
                D.37998 = iargs[0];
                D.37998->sreg3 = -1;
                D.38001 = D.37998->sreg3;
                D.37998->sreg2 = D.38001;
                D.38002 = D.37998->sreg2;
                D.37998->sreg1 = D.38002;
                D.37998 = iargs[0];
                D.31162 = cfg->ip;
                D.37998->cil_code = D.31162;
                D.37998 = iargs[0];
                addr.237 = (long int) addr;
                D.38003 = (unsigned int) addr.237;
                D.38004 = (long int) D.38003;
                D.37998->data.op[0].const_val = D.38004;
                D.37998 = iargs[0];
                D.37998->type = 1;
                D.37998 = iargs[0];
                D.38005 = alloc_dreg (cfg, 1);
                D.38006 = (int) D.38005;
                D.37998->dreg = D.38006;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38007>; else goto <D.38008>;
                <D.38007>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.37998 = iargs[0];
                D.31191->next = D.37998;
                D.37998 = iargs[0];
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.37998->prev = D.31191;
                bblock.113 = cfg->cbb;
                D.37998 = iargs[0];
                bblock.113->last_ins = D.37998;
                goto <D.38009>;
                <D.38008>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                D.37998 = iargs[0];
                bblock.113->last_ins = D.37998;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38009>:
                ins = mono_emit_jit_icall (cfg, mono_get_special_static_data, &iargs);
              }
            finally
              {
                iargs = {CLOBBER};
              }
          }
          <D.37996>:
        }
        <D.37858>:
        <D.37855>:
        <D.37762>:
        <D.37638>:
        if (op == 127) goto <D.38010>; else goto <D.38011>;
        <D.38010>:
        D.38012 = mono_class_from_mono_type (ftype);
        ins->klass = D.38012;
        ins->type = 3;
        sp.241 = sp;
        sp = sp.241 + 8;
        *sp.241 = ins;
        goto <D.38014>;
        <D.38011>:
        if (op == 128) goto <D.38015>; else goto <D.38016>;
        <D.38015>:
        {
          struct MonoInst * store;

          D.30941 = cfg->mempool;
          store = mono_mempool_alloc (D.30941, 80);
          store->data.op[1].const_val = 0;
          D.38017 = store->data.op[1].const_val;
          store->data.op[0].const_val = D.38017;
          store->prev = 0B;
          D.38018 = store->prev;
          store->next = D.38018;
          D.38019 = mono_type_to_store_membase (cfg, ftype);
          D.38020 = (short unsigned int) D.38019;
          store->opcode = D.38020;
          store->flags = 0;
          store->type = 0;
          store->dreg = -1;
          store->sreg3 = -1;
          D.38021 = store->sreg3;
          store->sreg2 = D.38021;
          D.38022 = store->sreg2;
          store->sreg1 = D.38022;
          D.31162 = cfg->ip;
          store->cil_code = D.31162;
          D.38023 = store_val->dreg;
          store->sreg1 = D.38023;
          D.31356 = ins->dreg;
          store->dreg = D.31356;
          store->data.op[0].const_val = 0;
          type_to_eval_stack_type (cfg, ftype, store);
          D.38024 = mono_class_from_mono_type (ftype);
          store->klass = D.38024;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.38025>; else goto <D.38026>;
          <D.38025>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = store;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          store->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = store;
          goto <D.38027>;
          <D.38026>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = store;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.38027>:
          D.38028 = store->flags;
          D.35267 = (unsigned char) ins_flag;
          D.38029 = D.38028 | D.35267;
          store->flags = D.38029;
        }
        goto <D.38030>;
        <D.38016>:
        {
          gboolean is_const;
          struct MonoVTable * vtable;
          void * addr;

          is_const = 0;
          vtable = 0B;
          addr = 0B;
          if (context_used == 0) goto <D.38031>; else goto <D.38032>;
          <D.38031>:
          D.30966 = cfg->domain;
          klass.157 = klass;
          vtable = mono_class_vtable (D.30966, klass.157);
          klass.157 = klass;
          if (klass.157 == 0B) goto <D.38033>; else goto <D.38035>;
          <D.38035>:
          klass.157 = klass;
          D.35652 = klass.157->exception_type;
          if (D.35652 != 0) goto <D.38033>; else goto <D.38034>;
          <D.38033>:
          klass.157 = klass;
          cfg->exception_ptr = klass.157;
          D.38036 = mini_get_debug_options ();
          D.38037 = D.38036->break_on_unverified;
          if (D.38037 != 0) goto <D.38038>; else goto load_error;
          <D.38038>:
          raise (5);
          <D.38034>:
          <D.38032>:
          D.37591 = ftype->attrs;
          D.37592 = (int) D.37591;
          D.38041 = D.37592 & 32;
          if (D.38041 != 0) goto <D.38042>; else goto <D.38043>;
          <D.38042>:
          addr = mono_aot_readonly_field_override (field);
          if (addr != 0B) goto <D.38039>; else goto <D.38044>;
          <D.38044>:
          if (context_used == 0) goto <D.38045>; else goto <D.38040>;
          <D.38045>:
          D.31334 = cfg->opt;
          D.31335 = D.31334 & 512;
          if (D.31335 == 0) goto <D.38046>; else goto <D.38040>;
          <D.38046>:
          D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31337 = D.31336 & 274877906944;
          if (D.31337 == 0) goto <D.38047>; else goto <D.38040>;
          <D.38047>:
          D.38048 = BIT_FIELD_REF <*vtable, 64, 320>;
          D.38049 = D.38048 & 33554432;
          if (D.38049 != 0) goto <D.38039>; else goto <D.38040>;
          <D.38039>:
          {
            int ro_type;

            D.38050 = ftype->type;
            ro_type = (int) D.38050;
            if (addr == 0B) goto <D.38051>; else goto <D.38052>;
            <D.38051>:
            D.38053 = mono_vtable_get_static_field_data (vtable);
            D.37155 = field->offset;
            D.37985 = (sizetype) D.37155;
            addr = D.38053 + D.37985;
            <D.38052>:
            if (ro_type == 17) goto <D.38054>; else goto <D.38055>;
            <D.38054>:
            D.38056 = ftype->data.klass;
            D.38057 = BIT_FIELD_REF <*D.38056, 64, 256>;
            D.38058 = D.38057 & 16;
            if (D.38058 != 0) goto <D.38059>; else goto <D.38060>;
            <D.38059>:
            D.38056 = ftype->data.klass;
            D.38061 = mono_class_enum_basetype (D.38056);
            D.38062 = D.38061->type;
            ro_type = (int) D.38062;
            <D.38060>:
            <D.38055>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.38063>; else goto <D.38064>;
            <D.38063>:
            D.30878 = method->klass;
            D.32629 = D.30878->name_space;
            D.30878 = method->klass;
            D.32630 = D.30878->name;
            D.32631 = method->name;
            D.32632 = method->signature;
            D.32633 = D.32632->param_count;
            D.32634 = (int) D.32633;
            D.38065 = mono_opcode_name (op);
            D.38066 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.38065, "method-to-ir.c", 10305);
            cfg->exception_message = D.38066;
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.38067>; else goto <D.38068>;
            <D.38067>:
            D.32639 = cfg->exception_message;
            printf ("%s\n", D.32639);
            <D.38068>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38064>:
            is_const = 1;
            switch (ro_type) <default: <D.28442>, case 2: <D.28419>, case 3: <D.28423>, case 4: <D.28422>, case 5: <D.28420>, case 6: <D.28425>, case 7: <D.28424>, case 8: <D.28426>, case 9: <D.28427>, case 10: <D.28437>, case 11: <D.28438>, case 12: <D.28439>, case 13: <D.28440>, case 14: <D.28432>, case 15: <D.28430>, case 17: <D.28441>, case 18: <D.28434>, case 20: <D.28436>, case 24: <D.28428>, case 25: <D.28429>, case 27: <D.28431>, case 28: <D.28433>, case 29: <D.28435>>
            <D.28419>:
            <D.28420>:
            D.30941 = cfg->mempool;
            D.38069 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38069;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38070 = MEM[(guint8 *)addr];
            D.38071 = (long int) D.38070;
            D.31957->data.op[0].const_val = D.38071;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38072 = alloc_dreg (cfg, 1);
            D.38073 = (int) D.38072;
            D.31957->dreg = D.38073;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38074>; else goto <D.38075>;
            <D.38074>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38076>;
            <D.38075>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38076>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28422>:
            D.30941 = cfg->mempool;
            D.38077 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38077;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38078 = MEM[(gint8 *)addr];
            D.38079 = (long int) D.38078;
            D.31957->data.op[0].const_val = D.38079;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38080 = alloc_dreg (cfg, 1);
            D.38081 = (int) D.38080;
            D.31957->dreg = D.38081;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38082>; else goto <D.38083>;
            <D.38082>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38084>;
            <D.38083>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38084>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28423>:
            <D.28424>:
            D.30941 = cfg->mempool;
            D.38085 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38085;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38086 = MEM[(guint16 *)addr];
            D.38087 = (long int) D.38086;
            D.31957->data.op[0].const_val = D.38087;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38088 = alloc_dreg (cfg, 1);
            D.38089 = (int) D.38088;
            D.31957->dreg = D.38089;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38090>; else goto <D.38091>;
            <D.38090>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38092>;
            <D.38091>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38092>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28425>:
            D.30941 = cfg->mempool;
            D.38093 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38093;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38094 = MEM[(gint16 *)addr];
            D.38095 = (long int) D.38094;
            D.31957->data.op[0].const_val = D.38095;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38096 = alloc_dreg (cfg, 1);
            D.38097 = (int) D.38096;
            D.31957->dreg = D.38097;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38098>; else goto <D.38099>;
            <D.38098>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38100>;
            <D.38099>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38100>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28426>:
            D.30941 = cfg->mempool;
            D.38101 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38101;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38102 = MEM[(gint32 *)addr];
            D.38103 = (long int) D.38102;
            D.31957->data.op[0].const_val = D.38103;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38104 = alloc_dreg (cfg, 1);
            D.38105 = (int) D.38104;
            D.31957->dreg = D.38105;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38106>; else goto <D.38107>;
            <D.38106>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38108>;
            <D.38107>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38108>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28427>:
            D.30941 = cfg->mempool;
            D.38109 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38109;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 362;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38110 = MEM[(guint32 *)addr];
            D.38111 = (long int) D.38110;
            D.31957->data.op[0].const_val = D.38111;
            D.31957 = *sp;
            D.31957->type = 1;
            D.31957 = *sp;
            D.38112 = alloc_dreg (cfg, 1);
            D.38113 = (int) D.38112;
            D.31957->dreg = D.38113;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38114>; else goto <D.38115>;
            <D.38114>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38116>;
            <D.38115>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38116>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28428>:
            <D.28429>:
            <D.28430>:
            <D.28431>:
            D.30941 = cfg->mempool;
            D.38117 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38117;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 363;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38118 = MEM[(void * *)addr];
            D.31957->data.op[0].p = D.38118;
            D.31957 = *sp;
            D.31957->type = 3;
            D.31957 = *sp;
            D.38119 = alloc_dreg (cfg, 3);
            D.38120 = (int) D.38119;
            D.31957->dreg = D.38120;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38121>; else goto <D.38122>;
            <D.38121>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38123>;
            <D.38122>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38123>:
            D.37145 = field->type;
            D.31957 = *sp;
            type_to_eval_stack_type (cfg, D.37145, D.31957);
            sp = sp + 8;
            goto <D.28421>;
            <D.28432>:
            <D.28433>:
            <D.28434>:
            <D.28435>:
            <D.28436>:
            D.38124 = mono_gc_is_moving ();
            if (D.38124 == 0) goto <D.38125>; else goto <D.38126>;
            <D.38125>:
            D.30941 = cfg->mempool;
            D.38127 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38127;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 363;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38118 = MEM[(void * *)addr];
            D.31957->data.op[0].p = D.38118;
            D.31957 = *sp;
            D.31957->type = 3;
            D.31957 = *sp;
            D.38128 = alloc_dreg (cfg, 3);
            D.38129 = (int) D.38128;
            D.31957->dreg = D.38129;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38130>; else goto <D.38131>;
            <D.38130>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38132>;
            <D.38131>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38132>:
            D.37145 = field->type;
            D.31957 = *sp;
            type_to_eval_stack_type (cfg, D.37145, D.31957);
            sp = sp + 8;
            goto <D.38133>;
            <D.38126>:
            is_const = 0;
            <D.38133>:
            goto <D.28421>;
            <D.28437>:
            <D.28438>:
            D.30941 = cfg->mempool;
            D.38134 = mono_mempool_alloc (D.30941, 80);
            *sp = D.38134;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->data.op[1].const_val = 0;
            D.33682 = D.31957->data.op[1].const_val;
            D.31957->data.op[0].const_val = D.33682;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->prev = 0B;
            D.33683 = D.31957->prev;
            D.31957->next = D.33683;
            D.31957 = *sp;
            D.31957->opcode = 363;
            D.31957 = *sp;
            D.31957->flags = 0;
            D.31957 = *sp;
            D.31957->type = 0;
            D.31957 = *sp;
            D.31957->dreg = -1;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957 = *sp;
            D.31957->sreg3 = -1;
            D.33684 = D.31957->sreg3;
            D.31957->sreg2 = D.33684;
            D.33685 = D.31957->sreg2;
            D.31957->sreg1 = D.33685;
            D.31957 = *sp;
            D.31162 = cfg->ip;
            D.31957->cil_code = D.31162;
            D.31957 = *sp;
            D.38135 = alloc_lreg (cfg);
            D.38136 = (int) D.38135;
            D.31957->dreg = D.38136;
            D.31957 = *sp;
            D.31957->type = 2;
            D.31957 = *sp;
            D.38137 = MEM[(gint64 *)addr];
            D.31957->data.i8const = D.38137;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38138>; else goto <D.38139>;
            <D.38138>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957 = *sp;
            D.31191->next = D.31957;
            D.31957 = *sp;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31957->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            goto <D.38140>;
            <D.38139>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.31957 = *sp;
            bblock.113->last_ins = D.31957;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38140>:
            sp = sp + 8;
            goto <D.28421>;
            <D.28439>:
            <D.28440>:
            <D.28441>:
            <D.28442>:
            is_const = 0;
            goto <D.28421>;
            <D.28421>:
          }
          <D.38040>:
          <D.38043>:
          if (is_const == 0) goto <D.38141>; else goto <D.38142>;
          <D.38141>:
          {
            struct MonoInst * load;

            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.31641 = header->max_stack;
            D.31863 = (long int) D.31641;
            if (D.31731 >= D.31863) goto <D.38143>; else goto <D.38144>;
            <D.38143>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.38145>; else goto <D.38146>;
            <D.38145>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.38147>; else goto <D.38148>;
            <D.38147>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38148>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38146>:
            D.38149 = mini_get_debug_options ();
            D.38150 = D.38149->break_on_unverified;
            if (D.38150 != 0) goto <D.38151>; else goto unverified;
            <D.38151>:
            raise (5);
            <D.38144>:
            D.30941 = cfg->mempool;
            load = mono_mempool_alloc (D.30941, 80);
            load->data.op[1].const_val = 0;
            D.38152 = load->data.op[1].const_val;
            load->data.op[0].const_val = D.38152;
            load->prev = 0B;
            D.38153 = load->prev;
            load->next = D.38153;
            D.37145 = field->type;
            D.38154 = mono_type_to_load_membase (cfg, D.37145);
            D.38155 = (short unsigned int) D.38154;
            load->opcode = D.38155;
            load->flags = 0;
            load->type = 0;
            load->dreg = -1;
            load->sreg3 = -1;
            D.38156 = load->sreg3;
            load->sreg2 = D.38156;
            D.38157 = load->sreg2;
            load->sreg1 = D.38157;
            D.31162 = cfg->ip;
            load->cil_code = D.31162;
            load->dreg = 0;
            D.31356 = ins->dreg;
            load->sreg1 = D.31356;
            load->data.op[0].const_val = 0;
            load->type = 1;
            D.37145 = field->type;
            type_to_eval_stack_type (cfg, D.37145, load);
            D.38158 = load->type;
            D.38159 = (<unnamed type>) D.38158;
            D.38160 = alloc_dreg (cfg, D.38159);
            D.38161 = (int) D.38160;
            load->dreg = D.38161;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38162>; else goto <D.38163>;
            <D.38162>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = load;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            load->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = load;
            goto <D.38164>;
            <D.38163>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = load;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38164>:
            D.38165 = load->flags;
            D.35267 = (unsigned char) ins_flag;
            D.38166 = D.38165 | D.35267;
            load->flags = D.38166;
            ins_flag = 0;
            sp.242 = sp;
            sp = sp.242 + 8;
            *sp.242 = load;
          }
          <D.38142>:
        }
        <D.38030>:
        <D.38014>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27857>;
      }
      <D.28444>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.38168>; else goto <D.38169>;
      <D.38168>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38170>; else goto <D.38171>;
      <D.38170>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38172>; else goto <D.38173>;
      <D.38172>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38173>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38171>:
      D.38174 = mini_get_debug_options ();
      D.38175 = D.38174->break_on_unverified;
      if (D.38175 != 0) goto <D.38176>; else goto unverified;
      <D.38176>:
      raise (5);
      <D.38169>:
      sp = sp + 18446744073709551600;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.38177>; else goto <D.38178>;
      <D.38177>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38179>; else goto <D.38180>;
      <D.38179>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38181>; else goto <D.38182>;
      <D.38181>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38182>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38180>:
      D.38183 = mini_get_debug_options ();
      D.38184 = D.38183->break_on_unverified;
      if (D.38184 != 0) goto <D.38185>; else goto unverified;
      <D.38185>:
      raise (5);
      <D.38178>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.243 = mini_get_class (method, token, generic_context);
      klass = klass.243;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.38187>; else goto <D.38189>;
      <D.38189>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.38187>; else goto <D.38188>;
      <D.38187>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.38190 = mini_get_debug_options ();
      D.38191 = D.38190->break_on_unverified;
      if (D.38191 != 0) goto <D.38192>; else goto load_error;
      <D.38192>:
      raise (5);
      <D.38188>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      klass.157 = klass;
      D.35726 = &klass.157->byval_arg;
      D.38193 = mono_type_to_store_membase (cfg, D.35726);
      D.38194 = (short unsigned int) D.38193;
      ins->opcode = D.38194;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      D.33091 = D.33090->dreg;
      ins->sreg1 = D.33091;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->dreg = D.32139;
      ins->data.op[0].const_val = 0;
      klass.157 = klass;
      D.35726 = &klass.157->byval_arg;
      type_to_eval_stack_type (cfg, D.35726, ins);
      klass.157 = klass;
      D.35726 = &klass.157->byval_arg;
      D.38195 = mono_class_from_mono_type (D.35726);
      ins->klass = D.38195;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.38196>; else goto <D.38197>;
      <D.38196>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.38198>;
      <D.38197>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.38198>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.34146 = D.31336 & 1152921504606846976;
      if (D.34146 != 0) goto <D.38199>; else goto <D.38200>;
      <D.38199>:
      D.30911 = cfg->method;
      D.32877 = BIT_FIELD_REF <*D.30911, 64, 256>;
      D.32878 = D.32877 & 124;
      if (D.32878 != 96) goto <D.38201>; else goto <D.38202>;
      <D.38201>:
      klass.157 = klass;
      D.38203 = generic_class_is_reference_type (cfg, klass.157);
      if (D.38203 != 0) goto <D.38204>; else goto <D.38205>;
      <D.38204>:
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      emit_write_barrier (cfg, D.31957, D.33090);
      <D.38205>:
      <D.38202>:
      <D.38200>:
      ins_flag = 0;
      ip = ip + 5;
      inline_costs = inline_costs + 1;
      goto <D.27857>;
      <D.28445>:
      {
        struct MonoInst * len_ins;
        const char * data_ptr;
        int data_size;
        guint32 field_token;

        try
          {
            data_size = 0;
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            if (D.31730 <= 7) goto <D.38206>; else goto <D.38207>;
            <D.38206>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.38208>; else goto <D.38209>;
            <D.38208>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.38210>; else goto <D.38211>;
            <D.38210>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38211>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38209>:
            D.38212 = mini_get_debug_options ();
            D.38213 = D.38212->break_on_unverified;
            if (D.38213 != 0) goto <D.38214>; else goto unverified;
            <D.38214>:
            raise (5);
            <D.38207>:
            sp = sp + 18446744073709551608;
            D.32381 = ip + 5;
            if (D.32381 > end) goto <D.38215>; else goto <D.38216>;
            <D.38215>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.38217>; else goto <D.38218>;
            <D.38217>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.38219>; else goto <D.38220>;
            <D.38219>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38220>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38218>:
            D.38221 = mini_get_debug_options ();
            D.38222 = D.38221->break_on_unverified;
            if (D.38222 != 0) goto <D.38223>; else goto unverified;
            <D.38223>:
            raise (5);
            <D.38216>:
            token = MEM[(const guint32 *)ip + 1B];
            klass.244 = mini_get_class (method, token, generic_context);
            klass = klass.244;
            klass.157 = klass;
            if (klass.157 == 0B) goto <D.38225>; else goto <D.38227>;
            <D.38227>:
            klass.157 = klass;
            D.35652 = klass.157->exception_type;
            if (D.35652 != 0) goto <D.38225>; else goto <D.38226>;
            <D.38225>:
            klass.157 = klass;
            cfg->exception_ptr = klass.157;
            D.38228 = mini_get_debug_options ();
            D.38229 = D.38228->break_on_unverified;
            if (D.38229 != 0) goto <D.38230>; else goto load_error;
            <D.38230>:
            raise (5);
            <D.38226>:
            klass.157 = klass;
            context_used = mini_class_check_context_used (cfg, klass.157);
            D.31957 = *sp;
            D.33688 = D.31957->type;
            D.38231 = D.33688 + 254;
            if (D.38231 <= 1) goto <D.38232>; else goto <D.38233>;
            <D.38232>:
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 528;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            ins->sreg1 = D.32139;
            ins->type = 1;
            D.38234 = alloc_ireg (cfg);
            D.38235 = (int) D.38234;
            ins->dreg = D.38235;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38236>; else goto <D.38237>;
            <D.38236>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.38238>;
            <D.38237>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38238>:
            D.38239 = mono_decompose_opcode (cfg, ins);
            *sp = D.38239;
            <D.38233>:
            if (context_used != 0) goto <D.38240>; else goto <D.38241>;
            <D.38240>:
            {
              struct MonoInst * args[3];
              struct MonoClass * array_class;
              struct MonoMethod * managed_alloc;

              try
                {
                  klass.157 = klass;
                  array_class = mono_array_class_get (klass.157, 1);
                  managed_alloc = mono_gc_get_managed_array_allocator (array_class);
                  D.38242 = emit_get_rgctx_klass (cfg, context_used, array_class, 2);
                  args[0] = D.38242;
                  D.31957 = *sp;
                  args[1] = D.31957;
                  if (managed_alloc != 0B) goto <D.38243>; else goto <D.38244>;
                  <D.38243>:
                  ins = mono_emit_method_call (cfg, managed_alloc, &args, 0B);
                  goto <D.38245>;
                  <D.38244>:
                  ins = mono_emit_jit_icall (cfg, mono_array_new_specific, &args);
                  <D.38245>:
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            goto <D.38246>;
            <D.38241>:
            D.31334 = cfg->opt;
            D.31335 = D.31334 & 512;
            if (D.31335 != 0) goto <D.38247>; else goto <D.38248>;
            <D.38247>:
            {
              struct MonoInst * iargs[3];

              try
                {
                  D.31334 = cfg->opt;
                  D.31335 = D.31334 & 512;
                  if (D.31335 != 0) goto <D.38249>; else goto <D.38252>;
                  <D.38252>:
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.38249>; else goto <D.38250>;
                  <D.38249>:
                  {
                    struct MonoInst * __domain_var;

                    __domain_var = mono_get_domainvar (cfg);
                    D.30941 = cfg->mempool;
                    D.38253 = mono_mempool_alloc (D.30941, 80);
                    iargs[0] = D.38253;
                    D.38254 = iargs[0];
                    D.38254 = iargs[0];
                    D.38254->data.op[1].const_val = 0;
                    D.38255 = D.38254->data.op[1].const_val;
                    D.38254->data.op[0].const_val = D.38255;
                    D.38254 = iargs[0];
                    D.38254 = iargs[0];
                    D.38254->prev = 0B;
                    D.38256 = D.38254->prev;
                    D.38254->next = D.38256;
                    D.38254 = iargs[0];
                    D.38254->opcode = 424;
                    D.38254 = iargs[0];
                    D.38254->flags = 0;
                    D.38254 = iargs[0];
                    D.38254->type = 0;
                    D.38254 = iargs[0];
                    D.38254->dreg = -1;
                    D.38254 = iargs[0];
                    D.38254 = iargs[0];
                    D.38254 = iargs[0];
                    D.38254->sreg3 = -1;
                    D.38257 = D.38254->sreg3;
                    D.38254->sreg2 = D.38257;
                    D.38258 = D.38254->sreg2;
                    D.38254->sreg1 = D.38258;
                    D.38254 = iargs[0];
                    D.31162 = cfg->ip;
                    D.38254->cil_code = D.31162;
                    D.38254 = iargs[0];
                    D.31695 = cfg->varinfo;
                    D.38259 = __domain_var->data.op[0].const_val;
                    D.38260 = (long unsigned int) D.38259;
                    D.38261 = D.38260 * 8;
                    D.38262 = D.31695 + D.38261;
                    D.38263 = *D.38262;
                    D.38264 = D.38263->data.op[1].vtype;
                    D.38265 = mono_type_to_regmove (cfg, D.38264);
                    D.38266 = (short unsigned int) D.38265;
                    D.38254->opcode = D.38266;
                    D.31695 = cfg->varinfo;
                    D.38259 = __domain_var->data.op[0].const_val;
                    D.38260 = (long unsigned int) D.38259;
                    D.38261 = D.38260 * 8;
                    D.38262 = D.31695 + D.38261;
                    D.38263 = *D.38262;
                    D.38264 = D.38263->data.op[1].vtype;
                    D.38254 = iargs[0];
                    type_to_eval_stack_type (cfg, D.38264, D.38254);
                    D.38254 = iargs[0];
                    D.31695 = cfg->varinfo;
                    D.38259 = __domain_var->data.op[0].const_val;
                    D.38260 = (long unsigned int) D.38259;
                    D.38261 = D.38260 * 8;
                    D.38262 = D.31695 + D.38261;
                    D.38263 = *D.38262;
                    D.38267 = D.38263->klass;
                    D.38254->klass = D.38267;
                    D.38254 = iargs[0];
                    D.31695 = cfg->varinfo;
                    D.38259 = __domain_var->data.op[0].const_val;
                    D.38260 = (long unsigned int) D.38259;
                    D.38261 = D.38260 * 8;
                    D.38262 = D.31695 + D.38261;
                    D.38263 = *D.38262;
                    D.38268 = D.38263->dreg;
                    D.38254->sreg1 = D.38268;
                    D.38254 = iargs[0];
                    D.38254 = iargs[0];
                    D.38269 = D.38254->type;
                    D.38270 = (<unnamed type>) D.38269;
                    D.38271 = alloc_dreg (cfg, D.38270);
                    D.38272 = (int) D.38271;
                    D.38254->dreg = D.38272;
                    D.38254 = iargs[0];
                    D.38273 = D.38254->opcode;
                    if (D.38273 == 427) goto <D.38274>; else goto <D.38275>;
                    <D.38274>:
                    D.38254 = iargs[0];
                    D.31695 = cfg->varinfo;
                    D.38259 = __domain_var->data.op[0].const_val;
                    D.38260 = (long unsigned int) D.38259;
                    D.38261 = D.38260 * 8;
                    D.38262 = D.31695 + D.38261;
                    D.38263 = *D.38262;
                    D.38264 = D.38263->data.op[1].vtype;
                    D.38276 = mono_class_from_mono_type (D.38264);
                    D.38254->klass = D.38276;
                    <D.38275>:
                  }
                  goto <D.38251>;
                  <D.38250>:
                  D.30941 = cfg->mempool;
                  D.38277 = mono_mempool_alloc (D.30941, 80);
                  iargs[0] = D.38277;
                  D.38254 = iargs[0];
                  D.38254 = iargs[0];
                  D.38254->data.op[1].const_val = 0;
                  D.38255 = D.38254->data.op[1].const_val;
                  D.38254->data.op[0].const_val = D.38255;
                  D.38254 = iargs[0];
                  D.38254 = iargs[0];
                  D.38254->prev = 0B;
                  D.38256 = D.38254->prev;
                  D.38254->next = D.38256;
                  D.38254 = iargs[0];
                  D.38254->opcode = 363;
                  D.38254 = iargs[0];
                  D.38254->flags = 0;
                  D.38254 = iargs[0];
                  D.38254->type = 0;
                  D.38254 = iargs[0];
                  D.38254->dreg = -1;
                  D.38254 = iargs[0];
                  D.38254 = iargs[0];
                  D.38254 = iargs[0];
                  D.38254->sreg3 = -1;
                  D.38257 = D.38254->sreg3;
                  D.38254->sreg2 = D.38257;
                  D.38258 = D.38254->sreg2;
                  D.38254->sreg1 = D.38258;
                  D.38254 = iargs[0];
                  D.31162 = cfg->ip;
                  D.38254->cil_code = D.31162;
                  D.38254 = iargs[0];
                  D.30966 = cfg->domain;
                  D.38254->data.op[0].p = D.30966;
                  D.38254 = iargs[0];
                  D.38254->type = 3;
                  D.38254 = iargs[0];
                  D.38278 = alloc_dreg (cfg, 3);
                  D.38279 = (int) D.38278;
                  D.38254->dreg = D.38279;
                  <D.38251>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38280>; else goto <D.38281>;
                  <D.38280>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38254 = iargs[0];
                  D.31191->next = D.38254;
                  D.38254 = iargs[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38254->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38254 = iargs[0];
                  bblock.113->last_ins = D.38254;
                  goto <D.38282>;
                  <D.38281>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38254 = iargs[0];
                  bblock.113->last_ins = D.38254;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38282>:
                  D.30941 = cfg->mempool;
                  D.38283 = mono_mempool_alloc (D.30941, 80);
                  iargs[1] = D.38283;
                  D.38284 = iargs[1];
                  D.38284 = iargs[1];
                  D.38284->data.op[1].const_val = 0;
                  D.38285 = D.38284->data.op[1].const_val;
                  D.38284->data.op[0].const_val = D.38285;
                  D.38284 = iargs[1];
                  D.38284 = iargs[1];
                  D.38284->prev = 0B;
                  D.38286 = D.38284->prev;
                  D.38284->next = D.38286;
                  D.38284 = iargs[1];
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.38288>; else goto <D.38289>;
                  <D.38288>:
                  iftmp.245 = 734;
                  goto <D.38290>;
                  <D.38289>:
                  iftmp.245 = 363;
                  <D.38290>:
                  D.38284->opcode = iftmp.245;
                  D.38284 = iargs[1];
                  D.38284->flags = 0;
                  D.38284 = iargs[1];
                  D.38284->type = 0;
                  D.38284 = iargs[1];
                  D.38284->dreg = -1;
                  D.38284 = iargs[1];
                  D.38284 = iargs[1];
                  D.38284 = iargs[1];
                  D.38284->sreg3 = -1;
                  D.38291 = D.38284->sreg3;
                  D.38284->sreg2 = D.38291;
                  D.38292 = D.38284->sreg2;
                  D.38284->sreg1 = D.38292;
                  D.38284 = iargs[1];
                  D.31162 = cfg->ip;
                  D.38284->cil_code = D.31162;
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.38293>; else goto <D.38294>;
                  <D.38293>:
                  {
                    struct MonoInst * group;
                    struct MonoInst * got_loc;

                    got_loc = mono_get_got_var (cfg);
                    D.30941 = cfg->mempool;
                    group = mono_mempool_alloc (D.30941, 80);
                    group->data.op[1].const_val = 0;
                    D.38295 = group->data.op[1].const_val;
                    group->data.op[0].const_val = D.38295;
                    group->prev = 0B;
                    D.38296 = group->prev;
                    group->next = D.38296;
                    group->opcode = 733;
                    group->flags = 0;
                    group->type = 0;
                    group->dreg = -1;
                    group->sreg3 = -1;
                    D.38297 = group->sreg3;
                    group->sreg2 = D.38297;
                    D.38298 = group->sreg2;
                    group->sreg1 = D.38298;
                    D.31162 = cfg->ip;
                    group->cil_code = D.31162;
                    klass.157 = klass;
                    group->data.op[0].src = klass.157;
                    group->data.op[1].src = 11B;
                    D.38284 = iargs[1];
                    D.38299 = got_loc->dreg;
                    D.38284->sreg1 = D.38299;
                    D.38284 = iargs[1];
                    D.38284->data.op[1].p = group;
                  }
                  goto <D.38300>;
                  <D.38294>:
                  D.38284 = iargs[1];
                  klass.157 = klass;
                  D.38284->data.op[0].p = klass.157;
                  D.38284 = iargs[1];
                  D.38284->data.op[1].src = 11B;
                  <D.38300>:
                  D.38284 = iargs[1];
                  D.38284->type = 3;
                  D.38284 = iargs[1];
                  D.38301 = alloc_dreg (cfg, 3);
                  D.38302 = (int) D.38301;
                  D.38284->dreg = D.38302;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38303>; else goto <D.38304>;
                  <D.38303>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38284 = iargs[1];
                  D.31191->next = D.38284;
                  D.38284 = iargs[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38284->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38284 = iargs[1];
                  bblock.113->last_ins = D.38284;
                  goto <D.38305>;
                  <D.38304>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38284 = iargs[1];
                  bblock.113->last_ins = D.38284;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38305>:
                  D.31957 = *sp;
                  iargs[2] = D.31957;
                  ins = mono_emit_jit_icall (cfg, mono_array_new, &iargs);
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            goto <D.38306>;
            <D.38248>:
            {
              struct MonoClass * array_type;

              klass.157 = klass;
              array_type = mono_array_class_get (klass.157, 1);
              D.30966 = cfg->domain;
              mono_class_vtable (D.30966, array_type);
              if (array_type == 0B) goto <D.38307>; else goto <D.38309>;
              <D.38309>:
              D.38310 = array_type->exception_type;
              if (D.38310 != 0) goto <D.38307>; else goto <D.38308>;
              <D.38307>:
              cfg->exception_ptr = array_type;
              D.38311 = mini_get_debug_options ();
              D.38312 = D.38311->break_on_unverified;
              if (D.38312 != 0) goto <D.38313>; else goto load_error;
              <D.38313>:
              raise (5);
              <D.38308>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 782;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              D.38314 = alloc_ireg_ref (cfg);
              D.38315 = (int) D.38314;
              ins->dreg = D.38315;
              D.31957 = *sp;
              D.32139 = D.31957->dreg;
              ins->sreg1 = D.32139;
              klass.157 = klass;
              ins->data.op[1].klass = klass.157;
              ins->type = 6;
              ins->klass = array_type;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38316>; else goto <D.38317>;
              <D.38316>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.38318>;
              <D.38317>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38318>:
              D.31372 = cfg->flags;
              D.38319 = D.31372 | 256;
              cfg->flags = D.38319;
              bblock.113 = cfg->cbb;
              bblock.113->has_array_access = 1;
              mono_get_got_var (cfg);
            }
            <D.38306>:
            <D.38246>:
            len_ins = *sp;
            ip = ip + 5;
            sp.246 = sp;
            sp = sp.246 + 8;
            *sp.246 = ins;
            inline_costs = inline_costs + 1;
            D.31334 = cfg->opt;
            D.33349 = D.31334 & 2048;
            if (D.33349 != 0) goto <D.38321>; else goto <D.38322>;
            <D.38321>:
            D.35709 = ip + 6;
            if (D.35709 < end) goto <D.38323>; else goto <D.38324>;
            <D.38323>:
            bblock.70 = bblock;
            D.38325 = ip + 6;
            D.38326 = ip_in_bb (cfg, bblock.70, D.38325);
            if (D.38326 != 0) goto <D.38327>; else goto <D.38328>;
            <D.38327>:
            D.38329 = len_ins->opcode;
            if (D.38329 == 362) goto <D.38330>; else goto <D.38331>;
            <D.38330>:
            D.32909 = cfg->compile_aot;
            D.32910 = (int) D.32909;
            klass.157 = klass;
            D.38332 = len_ins->data.op[0].const_val;
            D.38333 = (unsigned int) D.38332;
            data_ptr = initialize_array_data (method, D.32910, ip, klass.157, D.38333, &data_size, &field_token);
            if (data_ptr != 0B) goto <D.38334>; else goto <D.38335>;
            <D.38334>:
            {
              struct MonoMethod * memcpy_method;
              struct MonoInst * iargs[3];
              int add_reg;

              try
                {
                  memcpy_method = get_memcpy_method ();
                  D.38336 = alloc_ireg_mp (cfg);
                  add_reg = (int) D.38336;
                  D.30941 = cfg->mempool;
                  D.38337 = mono_mempool_alloc (D.30941, 80);
                  iargs[0] = D.38337;
                  D.38338 = iargs[0];
                  D.38338 = iargs[0];
                  D.38338->data.op[1].const_val = 0;
                  D.38339 = D.38338->data.op[1].const_val;
                  D.38338->data.op[0].const_val = D.38339;
                  D.38338 = iargs[0];
                  D.38338 = iargs[0];
                  D.38338->prev = 0B;
                  D.38340 = D.38338->prev;
                  D.38338->next = D.38340;
                  D.38338 = iargs[0];
                  D.38338->opcode = 538;
                  D.38338 = iargs[0];
                  D.38338->flags = 0;
                  D.38338 = iargs[0];
                  D.38338->type = 0;
                  D.38338 = iargs[0];
                  D.38338->dreg = -1;
                  D.38338 = iargs[0];
                  D.38338 = iargs[0];
                  D.38338 = iargs[0];
                  D.38338->sreg3 = -1;
                  D.38341 = D.38338->sreg3;
                  D.38338->sreg2 = D.38341;
                  D.38342 = D.38338->sreg2;
                  D.38338->sreg1 = D.38342;
                  D.38338 = iargs[0];
                  D.31162 = cfg->ip;
                  D.38338->cil_code = D.31162;
                  D.38338 = iargs[0];
                  D.38338->dreg = add_reg;
                  D.38338 = iargs[0];
                  D.31356 = ins->dreg;
                  D.38338->sreg1 = D.31356;
                  D.38338 = iargs[0];
                  D.38338->data.op[1].const_val = 32;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38343>; else goto <D.38344>;
                  <D.38343>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38338 = iargs[0];
                  D.31191->next = D.38338;
                  D.38338 = iargs[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38338->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38338 = iargs[0];
                  bblock.113->last_ins = D.38338;
                  goto <D.38345>;
                  <D.38344>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38338 = iargs[0];
                  bblock.113->last_ins = D.38338;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38345>:
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.38346>; else goto <D.38347>;
                  <D.38346>:
                  {
                    struct MonoInst * group;
                    struct MonoInst * got_loc;

                    D.30941 = cfg->mempool;
                    D.38348 = mono_mempool_alloc (D.30941, 80);
                    iargs[1] = D.38348;
                    D.38349 = iargs[1];
                    D.38349 = iargs[1];
                    D.38349->data.op[1].const_val = 0;
                    D.38350 = D.38349->data.op[1].const_val;
                    D.38349->data.op[0].const_val = D.38350;
                    D.38349 = iargs[1];
                    D.38349 = iargs[1];
                    D.38349->prev = 0B;
                    D.38351 = D.38349->prev;
                    D.38349->next = D.38351;
                    D.38349 = iargs[1];
                    D.38349->opcode = 734;
                    D.38349 = iargs[1];
                    D.38349->flags = 0;
                    D.38349 = iargs[1];
                    D.38349->type = 0;
                    D.38349 = iargs[1];
                    D.38349->dreg = -1;
                    D.38349 = iargs[1];
                    D.38349 = iargs[1];
                    D.38349 = iargs[1];
                    D.38349->sreg3 = -1;
                    D.38352 = D.38349->sreg3;
                    D.38349->sreg2 = D.38352;
                    D.38353 = D.38349->sreg2;
                    D.38349->sreg1 = D.38353;
                    D.38349 = iargs[1];
                    D.31162 = cfg->ip;
                    D.38349->cil_code = D.31162;
                    got_loc = mono_get_got_var (cfg);
                    D.30941 = cfg->mempool;
                    group = mono_mempool_alloc (D.30941, 80);
                    group->data.op[1].const_val = 0;
                    D.38354 = group->data.op[1].const_val;
                    group->data.op[0].const_val = D.38354;
                    group->prev = 0B;
                    D.38355 = group->prev;
                    group->next = D.38355;
                    group->opcode = 733;
                    group->flags = 0;
                    group->type = 0;
                    group->dreg = -1;
                    group->sreg3 = -1;
                    D.38356 = group->sreg3;
                    group->sreg2 = D.38356;
                    D.38357 = group->sreg2;
                    group->sreg1 = D.38357;
                    D.31162 = cfg->ip;
                    group->cil_code = D.31162;
                    group->data.op[0].src = 0B;
                    group->data.op[1].src = 29B;
                    D.30941 = cfg->mempool;
                    D.30878 = method->klass;
                    D.30879 = D.30878->image;
                    field_token.247 = field_token;
                    D.38359 = mono_jump_info_token_new2 (D.30941, D.30879, field_token.247, 0B);
                    group->data.op[0].p = D.38359;
                    D.38349 = iargs[1];
                    D.38360 = got_loc->dreg;
                    D.38349->sreg1 = D.38360;
                    D.38349 = iargs[1];
                    D.38349->data.op[1].p = group;
                    D.38349 = iargs[1];
                    D.38349->type = 3;
                    D.38349 = iargs[1];
                    D.38349->klass = 0B;
                    D.38349 = iargs[1];
                    D.38361 = alloc_dreg (cfg, 3);
                    D.38362 = (int) D.38361;
                    D.38349->dreg = D.38362;
                  }
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38363>; else goto <D.38364>;
                  <D.38363>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38349 = iargs[1];
                  D.31191->next = D.38349;
                  D.38349 = iargs[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38349->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38349 = iargs[1];
                  bblock.113->last_ins = D.38349;
                  goto <D.38365>;
                  <D.38364>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38349 = iargs[1];
                  bblock.113->last_ins = D.38349;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38365>:
                  goto <D.38366>;
                  <D.38347>:
                  D.30941 = cfg->mempool;
                  D.38367 = mono_mempool_alloc (D.30941, 80);
                  iargs[1] = D.38367;
                  D.38349 = iargs[1];
                  D.38349 = iargs[1];
                  D.38349->data.op[1].const_val = 0;
                  D.38350 = D.38349->data.op[1].const_val;
                  D.38349->data.op[0].const_val = D.38350;
                  D.38349 = iargs[1];
                  D.38349 = iargs[1];
                  D.38349->prev = 0B;
                  D.38351 = D.38349->prev;
                  D.38349->next = D.38351;
                  D.38349 = iargs[1];
                  D.38349->opcode = 363;
                  D.38349 = iargs[1];
                  D.38349->flags = 0;
                  D.38349 = iargs[1];
                  D.38349->type = 0;
                  D.38349 = iargs[1];
                  D.38349->dreg = -1;
                  D.38349 = iargs[1];
                  D.38349 = iargs[1];
                  D.38349 = iargs[1];
                  D.38349->sreg3 = -1;
                  D.38352 = D.38349->sreg3;
                  D.38349->sreg2 = D.38352;
                  D.38353 = D.38349->sreg2;
                  D.38349->sreg1 = D.38353;
                  D.38349 = iargs[1];
                  D.31162 = cfg->ip;
                  D.38349->cil_code = D.31162;
                  D.38349 = iargs[1];
                  D.38349->data.op[0].p = data_ptr;
                  D.38349 = iargs[1];
                  D.38349->type = 3;
                  D.38349 = iargs[1];
                  D.38368 = alloc_dreg (cfg, 3);
                  D.38369 = (int) D.38368;
                  D.38349->dreg = D.38369;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38370>; else goto <D.38371>;
                  <D.38370>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38349 = iargs[1];
                  D.31191->next = D.38349;
                  D.38349 = iargs[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38349->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38349 = iargs[1];
                  bblock.113->last_ins = D.38349;
                  goto <D.38372>;
                  <D.38371>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38349 = iargs[1];
                  bblock.113->last_ins = D.38349;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38372>:
                  <D.38366>:
                  D.30941 = cfg->mempool;
                  D.38373 = mono_mempool_alloc (D.30941, 80);
                  iargs[2] = D.38373;
                  D.38374 = iargs[2];
                  D.38374 = iargs[2];
                  D.38374->data.op[1].const_val = 0;
                  D.38375 = D.38374->data.op[1].const_val;
                  D.38374->data.op[0].const_val = D.38375;
                  D.38374 = iargs[2];
                  D.38374 = iargs[2];
                  D.38374->prev = 0B;
                  D.38376 = D.38374->prev;
                  D.38374->next = D.38376;
                  D.38374 = iargs[2];
                  D.38374->opcode = 362;
                  D.38374 = iargs[2];
                  D.38374->flags = 0;
                  D.38374 = iargs[2];
                  D.38374->type = 0;
                  D.38374 = iargs[2];
                  D.38374->dreg = -1;
                  D.38374 = iargs[2];
                  D.38374 = iargs[2];
                  D.38374 = iargs[2];
                  D.38374->sreg3 = -1;
                  D.38377 = D.38374->sreg3;
                  D.38374->sreg2 = D.38377;
                  D.38378 = D.38374->sreg2;
                  D.38374->sreg1 = D.38378;
                  D.38374 = iargs[2];
                  D.31162 = cfg->ip;
                  D.38374->cil_code = D.31162;
                  D.38374 = iargs[2];
                  data_size.248 = data_size;
                  D.38380 = (long int) data_size.248;
                  D.38374->data.op[0].const_val = D.38380;
                  D.38374 = iargs[2];
                  D.38374->type = 1;
                  D.38374 = iargs[2];
                  D.38381 = alloc_dreg (cfg, 1);
                  D.38382 = (int) D.38381;
                  D.38374->dreg = D.38382;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.38383>; else goto <D.38384>;
                  <D.38383>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38374 = iargs[2];
                  D.31191->next = D.38374;
                  D.38374 = iargs[2];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.38374->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.38374 = iargs[2];
                  bblock.113->last_ins = D.38374;
                  goto <D.38385>;
                  <D.38384>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.38374 = iargs[2];
                  bblock.113->last_ins = D.38374;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.38385>:
                  mono_emit_method_call (cfg, memcpy_method, &iargs, 0B);
                  ip = ip + 11;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.38335>:
            <D.38331>:
            <D.38328>:
            <D.38324>:
            <D.38322>:
            goto <D.27857>;
          }
        finally
          {
            data_size = {CLOBBER};
            field_token = {CLOBBER};
          }
      }
      <D.28463>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.38386>; else goto <D.38387>;
      <D.38386>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38388>; else goto <D.38389>;
      <D.38388>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38390>; else goto <D.38391>;
      <D.38390>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38391>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38389>:
      D.38392 = mini_get_debug_options ();
      D.38393 = D.38392->break_on_unverified;
      if (D.38393 != 0) goto <D.38394>; else goto unverified;
      <D.38394>:
      raise (5);
      <D.38387>:
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 != 6) goto <D.38395>; else goto <D.38396>;
      <D.38395>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38397>; else goto <D.38398>;
      <D.38397>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38399>; else goto <D.38400>;
      <D.38399>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38400>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38398>:
      D.38401 = mini_get_debug_options ();
      D.38402 = D.38401->break_on_unverified;
      if (D.38402 != 0) goto <D.38403>; else goto unverified;
      <D.38403>:
      raise (5);
      <D.38396>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 783;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.38404 = alloc_preg (cfg);
      D.38405 = (int) D.38404;
      ins->dreg = D.38405;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ins->type = 1;
      D.31805 = ins->flags;
      D.38406 = D.31805 | 32;
      ins->flags = D.38406;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.38407>; else goto <D.38408>;
      <D.38407>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.38409>;
      <D.38408>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.38409>:
      D.31372 = cfg->flags;
      D.38319 = D.31372 | 256;
      cfg->flags = D.38319;
      bblock.113 = cfg->cbb;
      bblock.113->has_array_access = 1;
      ip = ip + 1;
      sp.249 = sp;
      sp = sp.249 + 8;
      *sp.249 = ins;
      goto <D.27857>;
      <D.28464>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 15) goto <D.38411>; else goto <D.38412>;
      <D.38411>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38413>; else goto <D.38414>;
      <D.38413>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38415>; else goto <D.38416>;
      <D.38415>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38416>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38414>:
      D.38417 = mini_get_debug_options ();
      D.38418 = D.38417->break_on_unverified;
      if (D.38418 != 0) goto <D.38419>; else goto unverified;
      <D.38419>:
      raise (5);
      <D.38412>:
      sp = sp + 18446744073709551600;
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.38420>; else goto <D.38421>;
      <D.38420>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38422>; else goto <D.38423>;
      <D.38422>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38424>; else goto <D.38425>;
      <D.38424>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38425>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38423>:
      D.38426 = mini_get_debug_options ();
      D.38427 = D.38426->break_on_unverified;
      if (D.38427 != 0) goto <D.38428>; else goto unverified;
      <D.38428>:
      raise (5);
      <D.38421>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 != 6) goto <D.38429>; else goto <D.38430>;
      <D.38429>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38431>; else goto <D.38432>;
      <D.38431>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38433>; else goto <D.38434>;
      <D.38433>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38434>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38432>:
      D.38435 = mini_get_debug_options ();
      D.38436 = D.38435->break_on_unverified;
      if (D.38436 != 0) goto <D.38437>; else goto unverified;
      <D.38437>:
      raise (5);
      <D.38430>:
      D.31372 = cfg->flags;
      D.38438 = D.31372 | 4;
      cfg->flags = D.38438;
      D.32400 = ip + 1;
      D.32401 = *D.32400;
      klass.250 = mini_get_class (method, D.32401, generic_context);
      klass = klass.250;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.38440>; else goto <D.38442>;
      <D.38442>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.38440>; else goto <D.38441>;
      <D.38440>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.38443 = mini_get_debug_options ();
      D.38444 = D.38443->break_on_unverified;
      if (D.38444 != 0) goto <D.38445>; else goto load_error;
      <D.38445>:
      raise (5);
      <D.38441>:
      klass.157 = klass;
      D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
      D.37152 = D.36474 & 8;
      if (D.37152 == 0) goto <D.38446>; else goto <D.38447>;
      <D.38446>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      if (D.30884 == 0) goto <D.38448>; else goto <D.38449>;
      <D.38448>:
      if (readonly == 0) goto <D.38450>; else goto <D.38451>;
      <D.38450>:
      {
        struct MonoClass * array_class;

        klass.157 = klass;
        array_class = mono_array_class_get (klass.157, 1);
        D.31957 = *sp;
        mini_emit_check_array_type (cfg, D.31957, array_class);
        if (array_class == 0B) goto <D.38452>; else goto <D.38454>;
        <D.38454>:
        D.38455 = array_class->exception_type;
        if (D.38455 != 0) goto <D.38452>; else goto <D.38453>;
        <D.38452>:
        cfg->exception_ptr = array_class;
        D.38456 = mini_get_debug_options ();
        D.38457 = D.38456->break_on_unverified;
        if (D.38457 != 0) goto <D.38458>; else goto load_error;
        <D.38458>:
        raise (5);
        <D.38453>:
      }
      <D.38451>:
      <D.38449>:
      <D.38447>:
      readonly = 0;
      klass.157 = klass;
      D.31957 = *sp;
      D.33089 = sp + 8;
      D.33090 = *D.33089;
      ins = mini_emit_ldelema_1_ins (cfg, klass.157, D.31957, D.33090, 1);
      sp.251 = sp;
      sp = sp.251 + 8;
      *sp.251 = ins;
      ip = ip + 5;
      goto <D.27857>;
      <D.28466>:
      <D.28467>:
      <D.28468>:
      <D.28469>:
      <D.28470>:
      <D.28471>:
      <D.28472>:
      <D.28473>:
      <D.28474>:
      <D.28475>:
      <D.28476>:
      <D.28477>:
      {
        struct MonoInst * addr;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 15) goto <D.38460>; else goto <D.38461>;
        <D.38460>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38462>; else goto <D.38463>;
        <D.38462>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38464>; else goto <D.38465>;
        <D.38464>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38465>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38463>:
        D.38466 = mini_get_debug_options ();
        D.38467 = D.38466->break_on_unverified;
        if (D.38467 != 0) goto <D.38468>; else goto unverified;
        <D.38468>:
        raise (5);
        <D.38461>:
        sp = sp + 18446744073709551600;
        D.31838 = *ip;
        if (D.31838 == 163) goto <D.38469>; else goto <D.38470>;
        <D.38469>:
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.38471>; else goto <D.38472>;
        <D.38471>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38473>; else goto <D.38474>;
        <D.38473>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38475>; else goto <D.38476>;
        <D.38475>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38476>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38474>:
        D.38477 = mini_get_debug_options ();
        D.38478 = D.38477->break_on_unverified;
        if (D.38478 != 0) goto <D.38479>; else goto unverified;
        <D.38479>:
        raise (5);
        <D.38472>:
        token = MEM[(const guint32 *)ip + 1B];
        klass.252 = mini_get_class (method, token, generic_context);
        klass = klass.252;
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.38481>; else goto <D.38483>;
        <D.38483>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.38481>; else goto <D.38482>;
        <D.38481>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.38484 = mini_get_debug_options ();
        D.38485 = D.38484->break_on_unverified;
        if (D.38485 != 0) goto <D.38486>; else goto load_error;
        <D.38486>:
        raise (5);
        <D.38482>:
        klass.157 = klass;
        mono_class_init (klass.157);
        goto <D.38487>;
        <D.38470>:
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        klass.253 = array_access_to_klass (D.31839);
        klass = klass.253;
        <D.38487>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 != 6) goto <D.38489>; else goto <D.38490>;
        <D.38489>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38491>; else goto <D.38492>;
        <D.38491>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38493>; else goto <D.38494>;
        <D.38493>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38494>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38492>:
        D.38495 = mini_get_debug_options ();
        D.38496 = D.38495->break_on_unverified;
        if (D.38496 != 0) goto <D.38497>; else goto unverified;
        <D.38497>:
        raise (5);
        <D.38490>:
        D.31372 = cfg->flags;
        D.38438 = D.31372 | 4;
        cfg->flags = D.38438;
        klass.157 = klass;
        D.38498 = mini_is_gsharedvt_variable_klass (cfg, klass.157);
        if (D.38498 != 0) goto <D.38499>; else goto <D.38500>;
        <D.38499>:
        klass.157 = klass;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        addr = mini_emit_ldelema_1_ins (cfg, klass.157, D.31957, D.33090, 1);
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        D.38501 = mono_type_to_load_membase (cfg, D.35726);
        D.38502 = (short unsigned int) D.38501;
        ins->opcode = D.38502;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = 0;
        D.38503 = addr->dreg;
        ins->sreg1 = D.38503;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        type_to_eval_stack_type (cfg, D.35726, ins);
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.38504 = alloc_dreg (cfg, D.31706);
        D.38505 = (int) D.38504;
        ins->dreg = D.38505;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.38506>; else goto <D.38507>;
        <D.38506>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.38508>;
        <D.38507>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.38508>:
        ins->opcode = 399;
        goto <D.38509>;
        <D.38500>:
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.35301 = D.33090->opcode;
        if (D.35301 == 362) goto <D.38510>; else goto <D.38511>;
        <D.38510>:
        {
          int array_reg;
          int index_reg;
          int offset;

          D.31957 = *sp;
          array_reg = D.31957->dreg;
          D.33089 = sp + 8;
          D.33090 = *D.33089;
          index_reg = D.33090->dreg;
          klass.157 = klass;
          D.38512 = mono_class_array_element_size (klass.157);
          D.38513 = (unsigned int) D.38512;
          D.33089 = sp + 8;
          D.33090 = *D.33089;
          D.35326 = D.33090->data.op[0].const_val;
          D.38514 = (unsigned int) D.35326;
          D.38515 = D.38513 * D.38514;
          D.38516 = D.38515 + 32;
          offset = (int) D.38516;
          D.31334 = cfg->opt;
          D.38517 = D.31334 & 134217728;
          if (D.38517 == 0) goto <D.38518>; else goto <D.38519>;
          <D.38518>:
          D.31334 = cfg->opt;
          D.38520 = D.31334 & 262144;
          if (D.38520 == 0) goto <D.38521>; else goto <D.38522>;
          <D.38521>:
          D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.31587 = D.30929 & 64;
          if (D.31587 != 0) goto <D.38523>; else goto <D.38524>;
          <D.38523>:
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.38525 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.38525;
            inst->prev = 0B;
            D.38526 = inst->prev;
            inst->next = D.38526;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.38527 = inst->sreg3;
            inst->sreg2 = D.38527;
            D.38528 = inst->sreg2;
            inst->sreg1 = D.38528;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38529>; else goto <D.38530>;
            <D.38529>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.38531>;
            <D.38530>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38531>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.38532 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.38532;
            inst->prev = 0B;
            D.38533 = inst->prev;
            inst->next = D.38533;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.38534 = inst->sreg3;
            inst->sreg2 = D.38534;
            D.38535 = inst->sreg2;
            inst->sreg1 = D.38535;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->data.op[1].p = "NullReferenceException";
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38536>; else goto <D.38537>;
            <D.38536>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.38538>;
            <D.38537>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38538>:
          }
          goto <D.38539>;
          <D.38524>:
          <D.38539>:
          if (0 != 0) goto <D.38540>; else goto <D.38541>;
          <D.38540>:
          {
            int _length_reg;

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

              __ins_flags = 32;
              D.38545 = __ins_flags & 32;
              if (D.38545 != 0) goto <D.38546>; else goto <D.38547>;
              <D.38546>:
              D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.31587 = D.30929 & 64;
              if (D.31587 != 0) goto <D.38548>; else goto <D.38549>;
              <D.38548>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38550 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38550;
                inst->prev = 0B;
                D.38551 = inst->prev;
                inst->next = D.38551;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38552 = inst->sreg3;
                inst->sreg2 = D.38552;
                D.38553 = inst->sreg2;
                inst->sreg1 = D.38553;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38554>; else goto <D.38555>;
                <D.38554>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38556>;
                <D.38555>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38556>:
              }
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38557 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38557;
                inst->prev = 0B;
                D.38558 = inst->prev;
                inst->next = D.38558;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38559 = inst->sreg3;
                inst->sreg2 = D.38559;
                D.38560 = inst->sreg2;
                inst->sreg1 = D.38560;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->data.op[1].p = "NullReferenceException";
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38561>; else goto <D.38562>;
                <D.38561>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38563>;
                <D.38562>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38563>:
              }
              goto <D.38564>;
              <D.38549>:
              <D.38564>:
              <D.38547>:
              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38565 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38565;
              inst->prev = 0B;
              D.38566 = inst->prev;
              inst->next = D.38566;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38567 = inst->sreg3;
              inst->sreg2 = D.38567;
              D.38568 = inst->sreg2;
              inst->sreg1 = D.38568;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.38569 = (unsigned char) __ins_flags;
              inst->flags = D.38569;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38570>; else goto <D.38571>;
              <D.38570>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38572>;
              <D.38571>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38572>:
            }
            goto <D.38573>;
            <D.38544>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 64;
              D.38574 = __ins_flags & 32;
              if (D.38574 != 0) goto <D.38575>; else goto <D.38576>;
              <D.38575>:
              D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.31587 = D.30929 & 64;
              if (D.31587 != 0) goto <D.38577>; else goto <D.38578>;
              <D.38577>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38579 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38579;
                inst->prev = 0B;
                D.38580 = inst->prev;
                inst->next = D.38580;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38581 = inst->sreg3;
                inst->sreg2 = D.38581;
                D.38582 = inst->sreg2;
                inst->sreg1 = D.38582;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38583>; else goto <D.38584>;
                <D.38583>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38585>;
                <D.38584>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38585>:
              }
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38586 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38586;
                inst->prev = 0B;
                D.38587 = inst->prev;
                inst->next = D.38587;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38588 = inst->sreg3;
                inst->sreg2 = D.38588;
                D.38589 = inst->sreg2;
                inst->sreg1 = D.38589;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->data.op[1].p = "NullReferenceException";
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38590>; else goto <D.38591>;
                <D.38590>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38592>;
                <D.38591>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38592>:
              }
              goto <D.38593>;
              <D.38578>:
              <D.38593>:
              <D.38576>:
              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38594 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38594;
              inst->prev = 0B;
              D.38595 = inst->prev;
              inst->next = D.38595;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38596 = inst->sreg3;
              inst->sreg2 = D.38596;
              D.38597 = inst->sreg2;
              inst->sreg1 = D.38597;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.38598 = (unsigned char) __ins_flags;
              inst->flags = D.38598;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38599>; else goto <D.38600>;
              <D.38599>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38601>;
              <D.38600>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38601>:
            }
            <D.38573>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38602 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38602;
              inst->prev = 0B;
              D.38603 = inst->prev;
              inst->next = D.38603;
              inst->opcode = 322;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38604 = inst->sreg3;
              inst->sreg2 = D.38604;
              D.38605 = inst->sreg2;
              inst->sreg1 = D.38605;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              inst->sreg1 = _length_reg;
              inst->sreg2 = index_reg;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38606>; else goto <D.38607>;
              <D.38606>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38608>;
              <D.38607>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38608>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38609 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38609;
              inst->prev = 0B;
              D.38610 = inst->prev;
              inst->next = D.38610;
              inst->opcode = 459;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38611 = inst->sreg3;
              inst->sreg2 = D.38611;
              D.38612 = inst->sreg2;
              inst->sreg1 = D.38612;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->data.op[1].p = "IndexOutOfRangeException";
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38613>; else goto <D.38614>;
              <D.38613>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38615>;
              <D.38614>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38615>:
            }
          }
          goto <D.38616>;
          <D.38541>:
          {
            int _length_reg;

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

              __ins_flags = 32;
              D.38620 = __ins_flags & 32;
              if (D.38620 != 0) goto <D.38621>; else goto <D.38622>;
              <D.38621>:
              D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.31587 = D.30929 & 64;
              if (D.31587 != 0) goto <D.38623>; else goto <D.38624>;
              <D.38623>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38625 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38625;
                inst->prev = 0B;
                D.38626 = inst->prev;
                inst->next = D.38626;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38627 = inst->sreg3;
                inst->sreg2 = D.38627;
                D.38628 = inst->sreg2;
                inst->sreg1 = D.38628;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38629>; else goto <D.38630>;
                <D.38629>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38631>;
                <D.38630>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38631>:
              }
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38632 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38632;
                inst->prev = 0B;
                D.38633 = inst->prev;
                inst->next = D.38633;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38634 = inst->sreg3;
                inst->sreg2 = D.38634;
                D.38635 = inst->sreg2;
                inst->sreg1 = D.38635;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->data.op[1].p = "NullReferenceException";
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38636>; else goto <D.38637>;
                <D.38636>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38638>;
                <D.38637>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38638>:
              }
              goto <D.38639>;
              <D.38624>:
              <D.38639>:
              <D.38622>:
              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38640 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38640;
              inst->prev = 0B;
              D.38641 = inst->prev;
              inst->next = D.38641;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38642 = inst->sreg3;
              inst->sreg2 = D.38642;
              D.38643 = inst->sreg2;
              inst->sreg1 = D.38643;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.38644 = (unsigned char) __ins_flags;
              inst->flags = D.38644;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38645>; else goto <D.38646>;
              <D.38645>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38647>;
              <D.38646>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38647>:
            }
            goto <D.38648>;
            <D.38619>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 64;
              D.38649 = __ins_flags & 32;
              if (D.38649 != 0) goto <D.38650>; else goto <D.38651>;
              <D.38650>:
              D.30929 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.31587 = D.30929 & 64;
              if (D.31587 != 0) goto <D.38652>; else goto <D.38653>;
              <D.38652>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38654 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38654;
                inst->prev = 0B;
                D.38655 = inst->prev;
                inst->next = D.38655;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38656 = inst->sreg3;
                inst->sreg2 = D.38656;
                D.38657 = inst->sreg2;
                inst->sreg1 = D.38657;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38658>; else goto <D.38659>;
                <D.38658>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38660>;
                <D.38659>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38660>:
              }
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.38661 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38661;
                inst->prev = 0B;
                D.38662 = inst->prev;
                inst->next = D.38662;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38663 = inst->sreg3;
                inst->sreg2 = D.38663;
                D.38664 = inst->sreg2;
                inst->sreg1 = D.38664;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                inst->data.op[1].p = "NullReferenceException";
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.38665>; else goto <D.38666>;
                <D.38665>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.38667>;
                <D.38666>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.38667>:
              }
              goto <D.38668>;
              <D.38653>:
              <D.38668>:
              <D.38651>:
              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38669 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38669;
              inst->prev = 0B;
              D.38670 = inst->prev;
              inst->next = D.38670;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38671 = inst->sreg3;
              inst->sreg2 = D.38671;
              D.38672 = inst->sreg2;
              inst->sreg1 = D.38672;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.38673 = (unsigned char) __ins_flags;
              inst->flags = D.38673;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38674>; else goto <D.38675>;
              <D.38674>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38676>;
              <D.38675>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38676>:
            }
            <D.38648>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38677 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38677;
              inst->prev = 0B;
              D.38678 = inst->prev;
              inst->next = D.38678;
              inst->opcode = 322;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38679 = inst->sreg3;
              inst->sreg2 = D.38679;
              D.38680 = inst->sreg2;
              inst->sreg1 = D.38680;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              inst->sreg1 = _length_reg;
              inst->sreg2 = index_reg;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38681>; else goto <D.38682>;
              <D.38681>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38683>;
              <D.38682>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38683>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.38684 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38684;
              inst->prev = 0B;
              D.38685 = inst->prev;
              inst->next = D.38685;
              inst->opcode = 459;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38686 = inst->sreg3;
              inst->sreg2 = D.38686;
              D.38687 = inst->sreg2;
              inst->sreg1 = D.38687;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->data.op[1].p = "IndexOutOfRangeException";
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.38688>; else goto <D.38689>;
              <D.38688>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.38690>;
              <D.38689>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.38690>:
            }
          }
          <D.38616>:
          goto <D.38691>;
          <D.38522>:
          {
            struct MonoInst * ins;

            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.38692 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.38692;
            ins->prev = 0B;
            D.38693 = ins->prev;
            ins->next = D.38693;
            ins->opcode = 784;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.38694 = ins->sreg3;
            ins->sreg2 = D.38694;
            D.38695 = ins->sreg2;
            ins->sreg1 = D.38695;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->sreg1 = array_reg;
            ins->sreg2 = index_reg;
            ins->data.op[1].const_val = 24;
            D.38696 = ins->flags;
            D.38697 = D.38696 | 32;
            ins->flags = D.38697;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38698>; else goto <D.38699>;
            <D.38698>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.38700>;
            <D.38699>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38700>:
            D.31372 = cfg->flags;
            D.38319 = D.31372 | 256;
            cfg->flags = D.38319;
            bblock.113 = cfg->cbb;
            bblock.113->has_array_access = 1;
          }
          <D.38691>:
          <D.38519>:
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          klass.157 = klass;
          D.35726 = &klass.157->byval_arg;
          D.38701 = mono_type_to_load_membase (cfg, D.35726);
          D.38702 = (short unsigned int) D.38701;
          ins->opcode = D.38702;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->dreg = 0;
          ins->sreg1 = array_reg;
          D.38703 = (long int) offset;
          ins->data.op[0].const_val = D.38703;
          ins->type = 1;
          klass.157 = klass;
          D.35726 = &klass.157->byval_arg;
          type_to_eval_stack_type (cfg, D.35726, ins);
          D.31705 = ins->type;
          D.31706 = (<unnamed type>) D.31705;
          D.38704 = alloc_dreg (cfg, D.31706);
          D.38705 = (int) D.38704;
          ins->dreg = D.38705;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.38706>; else goto <D.38707>;
          <D.38706>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = ins;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          ins->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          goto <D.38708>;
          <D.38707>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = ins;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.38708>:
        }
        goto <D.38709>;
        <D.38511>:
        klass.157 = klass;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        addr = mini_emit_ldelema_1_ins (cfg, klass.157, D.31957, D.33090, 1);
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        D.38710 = mono_type_to_load_membase (cfg, D.35726);
        D.38711 = (short unsigned int) D.38710;
        ins->opcode = D.38711;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = 0;
        D.38503 = addr->dreg;
        ins->sreg1 = D.38503;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        type_to_eval_stack_type (cfg, D.35726, ins);
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.38712 = alloc_dreg (cfg, D.31706);
        D.38713 = (int) D.38712;
        ins->dreg = D.38713;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.38714>; else goto <D.38715>;
        <D.38714>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.38716>;
        <D.38715>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.38716>:
        <D.38709>:
        <D.38509>:
        sp.254 = sp;
        sp = sp.254 + 8;
        *sp.254 = ins;
        D.31838 = *ip;
        if (D.31838 == 163) goto <D.38718>; else goto <D.38719>;
        <D.38718>:
        ip = ip + 5;
        goto <D.38720>;
        <D.38719>:
        ip = ip + 1;
        <D.38720>:
        goto <D.27857>;
      }
      <D.28507>:
      <D.28508>:
      <D.28509>:
      <D.28510>:
      <D.28511>:
      <D.28512>:
      <D.28513>:
      <D.28514>:
      <D.28515>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 23) goto <D.38721>; else goto <D.38722>;
      <D.38721>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38723>; else goto <D.38724>;
      <D.38723>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38725>; else goto <D.38726>;
      <D.38725>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38726>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38724>:
      D.38727 = mini_get_debug_options ();
      D.38728 = D.38727->break_on_unverified;
      if (D.38728 != 0) goto <D.38729>; else goto unverified;
      <D.38729>:
      raise (5);
      <D.38722>:
      sp = sp + 18446744073709551592;
      D.31372 = cfg->flags;
      D.38438 = D.31372 | 4;
      cfg->flags = D.38438;
      D.31838 = *ip;
      if (D.31838 == 164) goto <D.38730>; else goto <D.38731>;
      <D.38730>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.38732>; else goto <D.38733>;
      <D.38732>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38734>; else goto <D.38735>;
      <D.38734>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 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>:
      token = MEM[(const guint32 *)ip + 1B];
      klass.255 = mini_get_class (method, token, generic_context);
      klass = klass.255;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.38742>; else goto <D.38744>;
      <D.38744>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.38742>; else goto <D.38743>;
      <D.38742>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.38745 = mini_get_debug_options ();
      D.38746 = D.38745->break_on_unverified;
      if (D.38746 != 0) goto <D.38747>; else goto load_error;
      <D.38747>:
      raise (5);
      <D.38743>:
      klass.157 = klass;
      mono_class_init (klass.157);
      goto <D.38748>;
      <D.38731>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      klass.256 = array_access_to_klass (D.31839);
      klass = klass.256;
      <D.38748>:
      D.31957 = *sp;
      D.33688 = D.31957->type;
      if (D.33688 != 6) goto <D.38750>; else goto <D.38751>;
      <D.38750>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38752>; else goto <D.38753>;
      <D.38752>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38754>; else goto <D.38755>;
      <D.38754>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38755>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38753>:
      D.38756 = mini_get_debug_options ();
      D.38757 = D.38756->break_on_unverified;
      if (D.38757 != 0) goto <D.38758>; else goto unverified;
      <D.38758>:
      raise (5);
      <D.38751>:
      klass.157 = klass;
      emit_array_store (cfg, klass.157, sp, 1);
      D.31838 = *ip;
      if (D.31838 == 164) goto <D.38759>; else goto <D.38760>;
      <D.38759>:
      ip = ip + 5;
      goto <D.38761>;
      <D.38760>:
      ip = ip + 1;
      <D.38761>:
      inline_costs = inline_costs + 1;
      goto <D.27857>;
      <D.28516>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.38762>; else goto <D.38763>;
      <D.38762>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.38764>; else goto <D.38765>;
      <D.38764>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.38766>; else goto <D.38767>;
      <D.38766>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38767>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38765>:
      D.38768 = mini_get_debug_options ();
      D.38769 = D.38768->break_on_unverified;
      if (D.38769 != 0) goto <D.38770>; else goto unverified;
      <D.38770>:
      raise (5);
      <D.38763>:
      sp = sp + 18446744073709551608;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 728;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.38771 = alloc_freg (cfg);
      D.38772 = (int) D.38771;
      ins->dreg = D.38772;
      ins->type = 4;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.38773>; else goto <D.38774>;
      <D.38773>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.38775>;
      <D.38774>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.38775>:
      sp.257 = sp;
      sp = sp.257 + 8;
      D.38777 = mono_decompose_opcode (cfg, ins);
      *sp.257 = D.38777;
      ip = ip + 1;
      goto <D.27857>;
      <D.28517>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;
        int klass_reg;
        int dreg;

        D.38778 = alloc_preg (cfg);
        klass_reg = (int) D.38778;
        D.38779 = alloc_preg (cfg);
        dreg = (int) D.38779;
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38780>; else goto <D.38781>;
        <D.38780>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        D.38782 = mono_opcode_name (D.31839);
        D.38783 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.38782, "method-to-ir.c", 10668);
        cfg->exception_message = D.38783;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.38784>; else goto <D.38785>;
        <D.38784>:
        D.32639 = cfg->exception_message;
        printf ("%s\n", D.32639);
        <D.38785>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38781>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.38786>; else goto <D.38787>;
        <D.38786>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38788>; else goto <D.38789>;
        <D.38788>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38790>; else goto <D.38791>;
        <D.38790>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38791>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38789>:
        D.38792 = mini_get_debug_options ();
        D.38793 = D.38792->break_on_unverified;
        if (D.38793 != 0) goto <D.38794>; else goto unverified;
        <D.38794>:
        raise (5);
        <D.38787>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.31838 = *ip;
        D.34621 = (short unsigned int) D.31838;
        ins->opcode = D.34621;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        sp = sp + 18446744073709551608;
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.38795>; else goto <D.38796>;
        <D.38795>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38797>; else goto <D.38798>;
        <D.38797>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38799>; else goto <D.38800>;
        <D.38799>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38800>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38798>:
        D.38801 = mini_get_debug_options ();
        D.38802 = D.38801->break_on_unverified;
        if (D.38802 != 0) goto <D.38803>; else goto unverified;
        <D.38803>:
        raise (5);
        <D.38796>:
        D.32400 = ip + 1;
        D.32401 = *D.32400;
        klass.258 = mono_class_get_full (image, D.32401, generic_context);
        klass = klass.258;
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.38805>; else goto <D.38807>;
        <D.38807>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.38805>; else goto <D.38806>;
        <D.38805>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.38808 = mini_get_debug_options ();
        D.38809 = D.38808->break_on_unverified;
        if (D.38809 != 0) goto <D.38810>; else goto load_error;
        <D.38810>:
        raise (5);
        <D.38806>:
        klass.157 = klass;
        mono_class_init (klass.157);
        klass.157 = klass;
        context_used = mini_class_check_context_used (cfg, klass.157);
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37427 = (unsigned int) D.32139;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.37427 < D.32058) goto <D.38812>; else goto <D.38813>;
        <D.38812>:
        D.32061 = cfg->vreg_to_inst;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37430 = (long unsigned int) D.32139;
        D.37431 = D.37430 * 8;
        D.37432 = D.32061 + D.37431;
        iftmp.259 = *D.37432;
        goto <D.38814>;
        <D.38813>:
        iftmp.259 = 0B;
        <D.38814>:
        src_var = iftmp.259;
        if (src_var == 0B) goto <D.38815>; else goto <D.38816>;
        <D.38815>:
        D.38817 = mono_defaults.typed_reference_class;
        D.38818 = &D.38817->byval_arg;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        src_var = mono_compile_create_var_for_vreg (cfg, D.38818, 329, D.32139);
        <D.38816>:
        D.30941 = cfg->mempool;
        src = mono_mempool_alloc (D.30941, 80);
        src->data.op[1].const_val = 0;
        D.38819 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.38819;
        src->prev = 0B;
        D.38820 = src->prev;
        src->next = D.38820;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.38821 = src->sreg3;
        src->sreg2 = D.38821;
        D.38822 = src->sreg2;
        src->sreg1 = D.38822;
        D.31162 = cfg->ip;
        src->cil_code = D.31162;
        src->data.op[0].p = src_var;
        D.38823 = src_var->flags;
        D.38824 = D.38823 | 16;
        src_var->flags = D.38824;
        src->type = 5;
        D.38825 = src_var->klass;
        src->klass = D.38825;
        D.38826 = alloc_dreg (cfg, 5);
        D.38827 = (int) D.38826;
        src->dreg = D.38827;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.38828>; else goto <D.38829>;
        <D.38828>:
        D.38830 = src_var->data.op[1].vtype;
        D.38831 = mini_is_gsharedvt_variable_type (cfg, D.38830);
        if (D.38831 != 0) goto <D.38832>; else goto <D.38833>;
        <D.38832>:
        handle_gsharedvt_ldaddr (cfg);
        <D.38833>:
        <D.38829>:
        if (0 != 0) goto <D.38834>; else goto <D.38835>;
        <D.38834>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.38837 = src_var->dreg;
          D.38838 = D.38837 + 1;
          D.38839 = (unsigned int) D.38838;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.38839 < D.32058) goto <D.38840>; else goto <D.38841>;
          <D.38840>:
          D.32061 = cfg->vreg_to_inst;
          D.38837 = src_var->dreg;
          D.38842 = (sizetype) D.38837;
          D.38843 = D.38842 + 1;
          D.38844 = D.38843 * 8;
          D.38845 = D.32061 + D.38844;
          iftmp.260 = *D.38845;
          goto <D.38846>;
          <D.38841>:
          iftmp.260 = 0B;
          <D.38846>:
          var1 = iftmp.260;
          D.38837 = src_var->dreg;
          D.38848 = D.38837 + 2;
          D.38849 = (unsigned int) D.38848;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.38849 < D.32058) goto <D.38850>; else goto <D.38851>;
          <D.38850>:
          D.32061 = cfg->vreg_to_inst;
          D.38837 = src_var->dreg;
          D.38842 = (sizetype) D.38837;
          D.38852 = D.38842 + 2;
          D.38853 = D.38852 * 8;
          D.38854 = D.32061 + D.38853;
          iftmp.261 = *D.38854;
          goto <D.38855>;
          <D.38851>:
          iftmp.261 = 0B;
          <D.38855>:
          var2 = iftmp.261;
          D.38856 = var1 == 0B;
          D.38857 = (long int) D.38856;
          D.38858 = __builtin_expect (D.38857, 0);
          if (D.38858 != 0) goto <D.38859>; else goto <D.38860>;
          <D.38859>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10684, "var1");
          <D.38860>:
          D.38861 = var2 == 0B;
          D.38862 = (long int) D.38861;
          D.38863 = __builtin_expect (D.38862, 0);
          if (D.38863 != 0) goto <D.38864>; else goto <D.38865>;
          <D.38864>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10684, "var2");
          <D.38865>:
          D.38866 = var1->flags;
          D.38867 = D.38866 | 16;
          var1->flags = D.38867;
          D.38868 = var2->flags;
          D.38869 = D.38868 | 16;
          var2->flags = D.38869;
        }
        <D.38835>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.38870>; else goto <D.38871>;
        <D.38870>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = src;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        src->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        goto <D.38872>;
        <D.38871>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.38872>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.38873 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.38873;
          inst->prev = 0B;
          D.38874 = inst->prev;
          inst->next = D.38874;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.38875 = inst->sreg3;
          inst->sreg2 = D.38875;
          D.38876 = inst->sreg2;
          inst->sreg1 = D.38876;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          inst->dreg = klass_reg;
          D.38877 = src->dreg;
          inst->sreg1 = D.38877;
          inst->data.op[0].const_val = 16;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.38878>; else goto <D.38879>;
          <D.38878>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.38880>;
          <D.38879>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.38880>:
        }
        if (context_used != 0) goto <D.38881>; else goto <D.38882>;
        <D.38881>:
        {
          struct MonoInst * klass_ins;

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

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.38883 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.38883;
            inst->prev = 0B;
            D.38884 = inst->prev;
            inst->next = D.38884;
            inst->opcode = 322;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.38885 = inst->sreg3;
            inst->sreg2 = D.38885;
            D.38886 = inst->sreg2;
            inst->sreg1 = D.38886;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = -1;
            inst->sreg1 = klass_reg;
            D.38887 = klass_ins->dreg;
            inst->sreg2 = D.38887;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38888>; else goto <D.38889>;
            <D.38888>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.38890>;
            <D.38889>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38890>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.38891 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.38891;
            inst->prev = 0B;
            D.38892 = inst->prev;
            inst->next = D.38892;
            inst->opcode = 456;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.38893 = inst->sreg3;
            inst->sreg2 = D.38893;
            D.38894 = inst->sreg2;
            inst->sreg1 = D.38894;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->data.op[1].p = "InvalidCastException";
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.38895>; else goto <D.38896>;
            <D.38895>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.38897>;
            <D.38896>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.38897>:
          }
        }
        goto <D.38898>;
        <D.38882>:
        klass.157 = klass;
        mini_emit_class_check (cfg, klass_reg, klass.157);
        <D.38898>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 388;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = dreg;
        D.38877 = src->dreg;
        ins->sreg1 = D.38877;
        ins->data.op[0].const_val = 8;
        ins->type = 1;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.38899>; else goto <D.38900>;
        <D.38899>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.38901>;
        <D.38900>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.38901>:
        ins->type = 5;
        sp.262 = sp;
        sp = sp.262 + 8;
        *sp.262 = ins;
        ip = ip + 5;
        goto <D.27857>;
      }
      <D.28528>:
      {
        struct MonoInst * loc;
        struct MonoInst * addr;

        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38903>; else goto <D.38904>;
        <D.38903>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        D.38905 = mono_opcode_name (D.31839);
        D.38906 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.38905, "method-to-ir.c", 10708);
        cfg->exception_message = D.38906;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.38907>; else goto <D.38908>;
        <D.38907>:
        D.32639 = cfg->exception_message;
        printf ("%s\n", D.32639);
        <D.38908>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38904>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.38909>; else goto <D.38910>;
        <D.38909>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38911>; else goto <D.38912>;
        <D.38911>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38913>; else goto <D.38914>;
        <D.38913>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38914>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38912>:
        D.38915 = mini_get_debug_options ();
        D.38916 = D.38915->break_on_unverified;
        if (D.38916 != 0) goto <D.38917>; else goto unverified;
        <D.38917>:
        raise (5);
        <D.38910>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.31838 = *ip;
        D.34621 = (short unsigned int) D.31838;
        ins->opcode = D.34621;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        sp = sp + 18446744073709551608;
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.38918>; else goto <D.38919>;
        <D.38918>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.38920>; else goto <D.38921>;
        <D.38920>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.38922>; else goto <D.38923>;
        <D.38922>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38923>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38921>:
        D.38924 = mini_get_debug_options ();
        D.38925 = D.38924->break_on_unverified;
        if (D.38925 != 0) goto <D.38926>; else goto unverified;
        <D.38926>:
        raise (5);
        <D.38919>:
        D.32400 = ip + 1;
        D.32401 = *D.32400;
        klass.263 = mono_class_get_full (image, D.32401, generic_context);
        klass = klass.263;
        klass.157 = klass;
        if (klass.157 == 0B) goto <D.38928>; else goto <D.38930>;
        <D.38930>:
        klass.157 = klass;
        D.35652 = klass.157->exception_type;
        if (D.35652 != 0) goto <D.38928>; else goto <D.38929>;
        <D.38928>:
        klass.157 = klass;
        cfg->exception_ptr = klass.157;
        D.38931 = mini_get_debug_options ();
        D.38932 = D.38931->break_on_unverified;
        if (D.38932 != 0) goto <D.38933>; else goto load_error;
        <D.38933>:
        raise (5);
        <D.38929>:
        klass.157 = klass;
        mono_class_init (klass.157);
        klass.157 = klass;
        context_used = mini_class_check_context_used (cfg, klass.157);
        D.38817 = mono_defaults.typed_reference_class;
        D.38818 = &D.38817->byval_arg;
        loc = mono_compile_create_var (cfg, D.38818, 329);
        D.30941 = cfg->mempool;
        addr = mono_mempool_alloc (D.30941, 80);
        addr->data.op[1].const_val = 0;
        D.38934 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.38934;
        addr->prev = 0B;
        D.38935 = addr->prev;
        addr->next = D.38935;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.38936 = addr->sreg3;
        addr->sreg2 = D.38936;
        D.38937 = addr->sreg2;
        addr->sreg1 = D.38937;
        D.31162 = cfg->ip;
        addr->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        addr->data.op[0].p = D.38942;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38943 = D.38942->flags;
        D.38944 = D.38943 | 16;
        D.38942->flags = D.38944;
        addr->type = 5;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38945 = D.38942->klass;
        addr->klass = D.38945;
        D.38946 = alloc_dreg (cfg, 5);
        D.38947 = (int) D.38946;
        addr->dreg = D.38947;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.38948>; else goto <D.38949>;
        <D.38948>:
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38950 = D.38942->data.op[1].vtype;
        D.38951 = mini_is_gsharedvt_variable_type (cfg, D.38950);
        if (D.38951 != 0) goto <D.38952>; else goto <D.38953>;
        <D.38952>:
        handle_gsharedvt_ldaddr (cfg);
        <D.38953>:
        <D.38949>:
        if (0 != 0) goto <D.38954>; else goto <D.38955>;
        <D.38954>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31695 = cfg->varinfo;
          D.38938 = loc->data.op[0].const_val;
          D.38939 = (long unsigned int) D.38938;
          D.38940 = D.38939 * 8;
          D.38941 = D.31695 + D.38940;
          D.38942 = *D.38941;
          D.38957 = D.38942->dreg;
          D.38958 = D.38957 + 1;
          D.38959 = (unsigned int) D.38958;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.38959 < D.32058) goto <D.38960>; else goto <D.38961>;
          <D.38960>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.38938 = loc->data.op[0].const_val;
          D.38939 = (long unsigned int) D.38938;
          D.38940 = D.38939 * 8;
          D.38941 = D.31695 + D.38940;
          D.38942 = *D.38941;
          D.38957 = D.38942->dreg;
          D.38962 = (sizetype) D.38957;
          D.38963 = D.38962 + 1;
          D.38964 = D.38963 * 8;
          D.38965 = D.32061 + D.38964;
          iftmp.264 = *D.38965;
          goto <D.38966>;
          <D.38961>:
          iftmp.264 = 0B;
          <D.38966>:
          var1 = iftmp.264;
          D.31695 = cfg->varinfo;
          D.38938 = loc->data.op[0].const_val;
          D.38939 = (long unsigned int) D.38938;
          D.38940 = D.38939 * 8;
          D.38941 = D.31695 + D.38940;
          D.38942 = *D.38941;
          D.38957 = D.38942->dreg;
          D.38968 = D.38957 + 2;
          D.38969 = (unsigned int) D.38968;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.38969 < D.32058) goto <D.38970>; else goto <D.38971>;
          <D.38970>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.38938 = loc->data.op[0].const_val;
          D.38939 = (long unsigned int) D.38938;
          D.38940 = D.38939 * 8;
          D.38941 = D.31695 + D.38940;
          D.38942 = *D.38941;
          D.38957 = D.38942->dreg;
          D.38962 = (sizetype) D.38957;
          D.38972 = D.38962 + 2;
          D.38973 = D.38972 * 8;
          D.38974 = D.32061 + D.38973;
          iftmp.265 = *D.38974;
          goto <D.38975>;
          <D.38971>:
          iftmp.265 = 0B;
          <D.38975>:
          var2 = iftmp.265;
          D.38976 = var1 == 0B;
          D.38977 = (long int) D.38976;
          D.38978 = __builtin_expect (D.38977, 0);
          if (D.38978 != 0) goto <D.38979>; else goto <D.38980>;
          <D.38979>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10721, "var1");
          <D.38980>:
          D.38981 = var2 == 0B;
          D.38982 = (long int) D.38981;
          D.38983 = __builtin_expect (D.38982, 0);
          if (D.38983 != 0) goto <D.38984>; else goto <D.38985>;
          <D.38984>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10721, "var2");
          <D.38985>:
          D.38986 = var1->flags;
          D.38987 = D.38986 | 16;
          var1->flags = D.38987;
          D.38988 = var2->flags;
          D.38989 = D.38988 | 16;
          var2->flags = D.38989;
        }
        <D.38955>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.38990>; else goto <D.38991>;
        <D.38990>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = addr;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        addr->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = addr;
        goto <D.38992>;
        <D.38991>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = addr;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.38992>:
        if (context_used != 0) goto <D.38993>; else goto <D.38994>;
        <D.38993>:
        {
          struct MonoInst * const_ins;
          int type_reg;

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

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.38996 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.38996;
            inst->prev = 0B;
            D.38997 = inst->prev;
            inst->next = D.38997;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.38998 = inst->sreg3;
            inst->sreg2 = D.38998;
            D.38999 = inst->sreg2;
            inst->sreg1 = D.38999;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            D.39000 = const_ins->dreg;
            inst->sreg1 = D.39000;
            D.39001 = addr->dreg;
            inst->dreg = D.39001;
            inst->data.op[0].const_val = 16;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39002>; else goto <D.39003>;
            <D.39002>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39004>;
            <D.39003>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39004>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39005 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39005;
            inst->prev = 0B;
            D.39006 = inst->prev;
            inst->next = D.39006;
            inst->opcode = 429;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39007 = inst->sreg3;
            inst->sreg2 = D.39007;
            D.39008 = inst->sreg2;
            inst->sreg1 = D.39008;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = type_reg;
            D.39000 = const_ins->dreg;
            inst->sreg1 = D.39000;
            inst->data.op[1].const_val = 200;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39009>; else goto <D.39010>;
            <D.39009>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39011>;
            <D.39010>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39011>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39012 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39012;
            inst->prev = 0B;
            D.39013 = inst->prev;
            inst->next = D.39013;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39014 = inst->sreg3;
            inst->sreg2 = D.39014;
            D.39015 = inst->sreg2;
            inst->sreg1 = D.39015;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->sreg1 = type_reg;
            D.39001 = addr->dreg;
            inst->dreg = D.39001;
            inst->data.op[0].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39016>; else goto <D.39017>;
            <D.39016>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39018>;
            <D.39017>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39018>:
          }
        }
        goto <D.39019>;
        <D.38994>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39020>; else goto <D.39021>;
        <D.39020>:
        {
          int const_reg;
          int type_reg;

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

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39024 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39024;
            inst->prev = 0B;
            D.39025 = inst->prev;
            inst->next = D.39025;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.39027>; else goto <D.39028>;
            <D.39027>:
            iftmp.266 = 734;
            goto <D.39029>;
            <D.39028>:
            iftmp.266 = 363;
            <D.39029>:
            inst->opcode = iftmp.266;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39030 = inst->sreg3;
            inst->sreg2 = D.39030;
            D.39031 = inst->sreg2;
            inst->sreg1 = D.39031;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.39032>; else goto <D.39033>;
            <D.39032>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.39034 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.39034;
              group->prev = 0B;
              D.39035 = group->prev;
              group->next = D.39035;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.39036 = group->sreg3;
              group->sreg2 = D.39036;
              D.39037 = group->sreg2;
              group->sreg1 = D.39037;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              klass.157 = klass;
              group->data.op[0].src = klass.157;
              group->data.op[1].src = 11B;
              D.39038 = got_loc->dreg;
              inst->sreg1 = D.39038;
              inst->data.op[1].p = group;
            }
            goto <D.39039>;
            <D.39033>:
            klass.157 = klass;
            inst->data.op[0].p = klass.157;
            inst->data.op[1].src = 11B;
            <D.39039>:
            inst->type = 3;
            D.39040 = alloc_dreg (cfg, 3);
            D.39041 = (int) D.39040;
            inst->dreg = D.39041;
            inst->dreg = const_reg;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39042>; else goto <D.39043>;
            <D.39042>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39044>;
            <D.39043>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39044>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39045 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39045;
            inst->prev = 0B;
            D.39046 = inst->prev;
            inst->next = D.39046;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39047 = inst->sreg3;
            inst->sreg2 = D.39047;
            D.39048 = inst->sreg2;
            inst->sreg1 = D.39048;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->sreg1 = const_reg;
            D.39001 = addr->dreg;
            inst->dreg = D.39001;
            inst->data.op[0].const_val = 16;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39049>; else goto <D.39050>;
            <D.39049>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39051>;
            <D.39050>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39051>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39052 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39052;
            inst->prev = 0B;
            D.39053 = inst->prev;
            inst->next = D.39053;
            inst->opcode = 429;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39054 = inst->sreg3;
            inst->sreg2 = D.39054;
            D.39055 = inst->sreg2;
            inst->sreg1 = D.39055;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->dreg = type_reg;
            inst->sreg1 = const_reg;
            inst->data.op[1].const_val = 200;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39056>; else goto <D.39057>;
            <D.39056>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39058>;
            <D.39057>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39058>:
          }
          {
            struct MonoInst * inst;

            D.30941 = cfg->mempool;
            inst = mono_mempool_alloc (D.30941, 80);
            inst->data.op[1].const_val = 0;
            D.39059 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.39059;
            inst->prev = 0B;
            D.39060 = inst->prev;
            inst->next = D.39060;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.39061 = inst->sreg3;
            inst->sreg2 = D.39061;
            D.39062 = inst->sreg2;
            inst->sreg1 = D.39062;
            D.31162 = cfg->ip;
            inst->cil_code = D.31162;
            inst->sreg1 = type_reg;
            D.39001 = addr->dreg;
            inst->dreg = D.39001;
            inst->data.op[0].const_val = 0;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39063>; else goto <D.39064>;
            <D.39063>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = inst;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            inst->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            goto <D.39065>;
            <D.39064>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = inst;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.39065>:
          }
        }
        goto <D.39066>;
        <D.39021>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.39067 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.39067;
          inst->prev = 0B;
          D.39068 = inst->prev;
          inst->next = D.39068;
          inst->opcode = 385;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.39069 = inst->sreg3;
          inst->sreg2 = D.39069;
          D.39070 = inst->sreg2;
          inst->sreg1 = D.39070;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.39001 = addr->dreg;
          inst->dreg = D.39001;
          inst->data.op[0].const_val = 0;
          klass.157 = klass;
          D.35726 = &klass.157->byval_arg;
          D.39071 = (long int) D.35726;
          inst->data.op[1].const_val = D.39071;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.39072>; else goto <D.39073>;
          <D.39072>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.39074>;
          <D.39073>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.39074>:
        }
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.39075 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.39075;
          inst->prev = 0B;
          D.39076 = inst->prev;
          inst->next = D.39076;
          inst->opcode = 385;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.39077 = inst->sreg3;
          inst->sreg2 = D.39077;
          D.39078 = inst->sreg2;
          inst->sreg1 = D.39078;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.39001 = addr->dreg;
          inst->dreg = D.39001;
          inst->data.op[0].const_val = 16;
          klass.157 = klass;
          klass.267 = (long int) klass.157;
          inst->data.op[1].const_val = klass.267;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.39080>; else goto <D.39081>;
          <D.39080>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.39082>;
          <D.39081>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.39082>:
        }
        <D.39066>:
        <D.39019>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.39083 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.39083;
          inst->prev = 0B;
          D.39084 = inst->prev;
          inst->next = D.39084;
          inst->opcode = 378;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.39085 = inst->sreg3;
          inst->sreg2 = D.39085;
          D.39086 = inst->sreg2;
          inst->sreg1 = D.39086;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.31957 = *sp;
          D.32139 = D.31957->dreg;
          inst->sreg1 = D.32139;
          D.39001 = addr->dreg;
          inst->dreg = D.39001;
          inst->data.op[0].const_val = 8;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.39087>; else goto <D.39088>;
          <D.39087>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.39089>;
          <D.39088>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.39089>:
        }
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38950 = D.38942->data.op[1].vtype;
        D.39090 = mono_type_to_regmove (cfg, D.38950);
        D.39091 = (short unsigned int) D.39090;
        ins->opcode = D.39091;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38950 = D.38942->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.38950, ins);
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38945 = D.38942->klass;
        ins->klass = D.38945;
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38957 = D.38942->dreg;
        ins->sreg1 = D.38957;
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.39092 = alloc_dreg (cfg, D.31706);
        D.39093 = (int) D.39092;
        ins->dreg = D.39093;
        D.31709 = ins->opcode;
        if (D.31709 == 427) goto <D.39094>; else goto <D.39095>;
        <D.39094>:
        D.31695 = cfg->varinfo;
        D.38938 = loc->data.op[0].const_val;
        D.38939 = (long unsigned int) D.38938;
        D.38940 = D.38939 * 8;
        D.38941 = D.31695 + D.38940;
        D.38942 = *D.38941;
        D.38950 = D.38942->data.op[1].vtype;
        D.39096 = mono_class_from_mono_type (D.38950);
        ins->klass = D.39096;
        <D.39095>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39097>; else goto <D.39098>;
        <D.39097>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39099>;
        <D.39098>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39099>:
        ins->type = 7;
        D.38817 = mono_defaults.typed_reference_class;
        ins->klass = D.38817;
        sp.268 = sp;
        sp = sp.268 + 8;
        *sp.268 = ins;
        ip = ip + 5;
        goto <D.27857>;
      }
      <D.28549>:
      {
        void * handle;
        struct MonoClass * handle_class;

        try
          {
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.31641 = header->max_stack;
            D.31863 = (long int) D.31641;
            if (D.31731 >= D.31863) goto <D.39101>; else goto <D.39102>;
            <D.39101>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.39103>; else goto <D.39104>;
            <D.39103>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.39105>; else goto <D.39106>;
            <D.39105>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39106>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39104>:
            D.39107 = mini_get_debug_options ();
            D.39108 = D.39107->break_on_unverified;
            if (D.39108 != 0) goto <D.39109>; else goto unverified;
            <D.39109>:
            raise (5);
            <D.39102>:
            D.32381 = ip + 5;
            if (D.32381 > end) goto <D.39110>; else goto <D.39111>;
            <D.39110>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.39112>; else goto <D.39113>;
            <D.39112>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.39114>; else goto <D.39115>;
            <D.39114>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39115>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39113>:
            D.39116 = mini_get_debug_options ();
            D.39117 = D.39116->break_on_unverified;
            if (D.39117 != 0) goto <D.39118>; else goto unverified;
            <D.39118>:
            raise (5);
            <D.39111>:
            D.32400 = ip + 1;
            D.32401 = *D.32400;
            n = (int) D.32401;
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 68) goto <D.39119>; else goto <D.39122>;
            <D.39122>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 64) goto <D.39119>; else goto <D.39120>;
            <D.39119>:
            n.161 = (unsigned int) n;
            handle = mono_method_get_wrapper_data (method, n.161);
            D.39123 = n + 1;
            D.39124 = (unsigned int) D.39123;
            handle_class.269 = mono_method_get_wrapper_data (method, D.39124);
            handle_class = handle_class.269;
            D.39126 = mono_defaults.typehandle_class;
            handle_class.270 = handle_class;
            if (D.39126 == handle_class.270) goto <D.39128>; else goto <D.39129>;
            <D.39128>:
            handle = &MEM[(struct MonoClass *)handle].byval_arg;
            <D.39129>:
            goto <D.39121>;
            <D.39120>:
            n.164 = (unsigned int) n;
            handle = mono_ldtoken (image, n.164, &handle_class, generic_context);
            <D.39121>:
            if (handle == 0B) goto <D.39130>; else goto <D.39131>;
            <D.39130>:
            D.39132 = mini_get_debug_options ();
            D.39133 = D.39132->break_on_unverified;
            if (D.39133 != 0) goto <D.39134>; else goto load_error;
            <D.39134>:
            raise (5);
            <D.39131>:
            handle_class.270 = handle_class;
            mono_class_init (handle_class.270);
            D.30977 = cfg->generic_sharing_context;
            if (D.30977 != 0B) goto <D.39135>; else goto <D.39136>;
            <D.39135>:
            D.39137 = n >> 24;
            D.39138 = (unsigned int) D.39137;
            D.39139 = D.39138 + 4294967295;
            if (D.39139 <= 1) goto <D.39140>; else goto <D.39141>;
            <D.39140>:
            context_used = 0;
            goto <D.39142>;
            <D.39141>:
            D.39126 = mono_defaults.typehandle_class;
            handle_class.270 = handle_class;
            if (D.39126 == handle_class.270) goto <D.39143>; else goto <D.39144>;
            <D.39143>:
            D.39145 = mono_type_get_type (handle);
            if (D.39145 == 18) goto <D.39146>; else goto <D.39147>;
            <D.39146>:
            context_used = 0;
            goto <D.39148>;
            <D.39147>:
            D.39149 = mono_class_from_mono_type (handle);
            context_used = mini_class_check_context_used (cfg, D.39149);
            <D.39148>:
            goto <D.39150>;
            <D.39144>:
            D.39151 = mono_defaults.fieldhandle_class;
            handle_class.270 = handle_class;
            if (D.39151 == handle_class.270) goto <D.39152>; else goto <D.39153>;
            <D.39152>:
            D.39154 = MEM[(struct MonoClassField *)handle].parent;
            context_used = mini_class_check_context_used (cfg, D.39154);
            goto <D.39155>;
            <D.39153>:
            D.39156 = mono_defaults.methodhandle_class;
            handle_class.270 = handle_class;
            if (D.39156 == handle_class.270) goto <D.39157>; else goto <D.39158>;
            <D.39157>:
            context_used = mini_method_check_context_used (cfg, handle);
            goto <D.39159>;
            <D.39158>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10795);
            <D.39159>:
            <D.39155>:
            <D.39150>:
            <D.39142>:
            <D.39136>:
            D.31334 = cfg->opt;
            D.31335 = D.31334 & 512;
            if (D.31335 != 0) goto <D.39162>; else goto <D.39160>;
            <D.39162>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 != 68) goto <D.39163>; else goto <D.39160>;
            <D.39163>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 != 64) goto <D.39164>; else goto <D.39160>;
            <D.39164>:
            {
              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.270 = handle_class;
                  D.39165 = &handle_class.270->byval_arg;
                  vtvar = mono_compile_create_var (cfg, D.39165, 329);
                  D.30941 = cfg->mempool;
                  D.39166 = mono_mempool_alloc (D.30941, 80);
                  iargs[0] = D.39166;
                  D.39167 = iargs[0];
                  D.39167 = iargs[0];
                  D.39167->data.op[1].const_val = 0;
                  D.39168 = D.39167->data.op[1].const_val;
                  D.39167->data.op[0].const_val = D.39168;
                  D.39167 = iargs[0];
                  D.39167 = iargs[0];
                  D.39167->prev = 0B;
                  D.39169 = D.39167->prev;
                  D.39167->next = D.39169;
                  D.39167 = iargs[0];
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.39171>; else goto <D.39172>;
                  <D.39171>:
                  iftmp.271 = 734;
                  goto <D.39173>;
                  <D.39172>:
                  iftmp.271 = 363;
                  <D.39173>:
                  D.39167->opcode = iftmp.271;
                  D.39167 = iargs[0];
                  D.39167->flags = 0;
                  D.39167 = iargs[0];
                  D.39167->type = 0;
                  D.39167 = iargs[0];
                  D.39167->dreg = -1;
                  D.39167 = iargs[0];
                  D.39167 = iargs[0];
                  D.39167 = iargs[0];
                  D.39167->sreg3 = -1;
                  D.39174 = D.39167->sreg3;
                  D.39167->sreg2 = D.39174;
                  D.39175 = D.39167->sreg2;
                  D.39167->sreg1 = D.39175;
                  D.39167 = iargs[0];
                  D.31162 = cfg->ip;
                  D.39167->cil_code = D.31162;
                  D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.31337 = D.31336 & 274877906944;
                  if (D.31337 != 0) goto <D.39176>; else goto <D.39177>;
                  <D.39176>:
                  {
                    struct MonoInst * group;
                    struct MonoInst * got_loc;

                    got_loc = mono_get_got_var (cfg);
                    D.30941 = cfg->mempool;
                    group = mono_mempool_alloc (D.30941, 80);
                    group->data.op[1].const_val = 0;
                    D.39178 = group->data.op[1].const_val;
                    group->data.op[0].const_val = D.39178;
                    group->prev = 0B;
                    D.39179 = group->prev;
                    group->next = D.39179;
                    group->opcode = 733;
                    group->flags = 0;
                    group->type = 0;
                    group->dreg = -1;
                    group->sreg3 = -1;
                    D.39180 = group->sreg3;
                    group->sreg2 = D.39180;
                    D.39181 = group->sreg2;
                    group->sreg1 = D.39181;
                    D.31162 = cfg->ip;
                    group->cil_code = D.31162;
                    group->data.op[0].src = image;
                    group->data.op[1].src = 12B;
                    D.39167 = iargs[0];
                    D.39182 = got_loc->dreg;
                    D.39167->sreg1 = D.39182;
                    D.39167 = iargs[0];
                    D.39167->data.op[1].p = group;
                  }
                  goto <D.39183>;
                  <D.39177>:
                  D.39167 = iargs[0];
                  D.39167->data.op[0].p = image;
                  D.39167 = iargs[0];
                  D.39167->data.op[1].src = 12B;
                  <D.39183>:
                  D.39167 = iargs[0];
                  D.39167->type = 3;
                  D.39167 = iargs[0];
                  D.39184 = alloc_dreg (cfg, 3);
                  D.39185 = (int) D.39184;
                  D.39167->dreg = D.39185;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.39186>; else goto <D.39187>;
                  <D.39186>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39167 = iargs[0];
                  D.31191->next = D.39167;
                  D.39167 = iargs[0];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39167->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.39167 = iargs[0];
                  bblock.113->last_ins = D.39167;
                  goto <D.39188>;
                  <D.39187>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.39167 = iargs[0];
                  bblock.113->last_ins = D.39167;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.39188>:
                  D.30941 = cfg->mempool;
                  D.39189 = mono_mempool_alloc (D.30941, 80);
                  iargs[1] = D.39189;
                  D.39190 = iargs[1];
                  D.39190 = iargs[1];
                  D.39190->data.op[1].const_val = 0;
                  D.39191 = D.39190->data.op[1].const_val;
                  D.39190->data.op[0].const_val = D.39191;
                  D.39190 = iargs[1];
                  D.39190 = iargs[1];
                  D.39190->prev = 0B;
                  D.39192 = D.39190->prev;
                  D.39190->next = D.39192;
                  D.39190 = iargs[1];
                  D.39190->opcode = 362;
                  D.39190 = iargs[1];
                  D.39190->flags = 0;
                  D.39190 = iargs[1];
                  D.39190->type = 0;
                  D.39190 = iargs[1];
                  D.39190->dreg = -1;
                  D.39190 = iargs[1];
                  D.39190 = iargs[1];
                  D.39190 = iargs[1];
                  D.39190->sreg3 = -1;
                  D.39193 = D.39190->sreg3;
                  D.39190->sreg2 = D.39193;
                  D.39194 = D.39190->sreg2;
                  D.39190->sreg1 = D.39194;
                  D.39190 = iargs[1];
                  D.31162 = cfg->ip;
                  D.39190->cil_code = D.31162;
                  D.39190 = iargs[1];
                  D.39195 = (long int) n;
                  D.39190->data.op[0].const_val = D.39195;
                  D.39190 = iargs[1];
                  D.39190->type = 1;
                  D.39190 = iargs[1];
                  D.39196 = alloc_dreg (cfg, 1);
                  D.39197 = (int) D.39196;
                  D.39190->dreg = D.39197;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.39198>; else goto <D.39199>;
                  <D.39198>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39190 = iargs[1];
                  D.31191->next = D.39190;
                  D.39190 = iargs[1];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39190->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.39190 = iargs[1];
                  bblock.113->last_ins = D.39190;
                  goto <D.39200>;
                  <D.39199>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.39190 = iargs[1];
                  bblock.113->last_ins = D.39190;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.39200>:
                  if (method_context_used != 0) goto <D.39201>; else goto <D.39202>;
                  <D.39201>:
                  D.39203 = emit_get_rgctx_method (cfg, method_context_used, method, 5);
                  iargs[2] = D.39203;
                  ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper_generic_shared, &iargs);
                  goto <D.39204>;
                  <D.39202>:
                  D.30941 = cfg->mempool;
                  D.39205 = mono_mempool_alloc (D.30941, 80);
                  iargs[2] = D.39205;
                  D.39206 = iargs[2];
                  D.39206 = iargs[2];
                  D.39206->data.op[1].const_val = 0;
                  D.39207 = D.39206->data.op[1].const_val;
                  D.39206->data.op[0].const_val = D.39207;
                  D.39206 = iargs[2];
                  D.39206 = iargs[2];
                  D.39206->prev = 0B;
                  D.39208 = D.39206->prev;
                  D.39206->next = D.39208;
                  D.39206 = iargs[2];
                  D.39206->opcode = 363;
                  D.39206 = iargs[2];
                  D.39206->flags = 0;
                  D.39206 = iargs[2];
                  D.39206->type = 0;
                  D.39206 = iargs[2];
                  D.39206->dreg = -1;
                  D.39206 = iargs[2];
                  D.39206 = iargs[2];
                  D.39206 = iargs[2];
                  D.39206->sreg3 = -1;
                  D.39209 = D.39206->sreg3;
                  D.39206->sreg2 = D.39209;
                  D.39210 = D.39206->sreg2;
                  D.39206->sreg1 = D.39210;
                  D.39206 = iargs[2];
                  D.31162 = cfg->ip;
                  D.39206->cil_code = D.31162;
                  D.39206 = iargs[2];
                  D.39206->data.op[0].p = generic_context;
                  D.39206 = iargs[2];
                  D.39206->type = 3;
                  D.39206 = iargs[2];
                  D.39211 = alloc_dreg (cfg, 3);
                  D.39212 = (int) D.39211;
                  D.39206->dreg = D.39212;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.39213>; else goto <D.39214>;
                  <D.39213>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39206 = iargs[2];
                  D.31191->next = D.39206;
                  D.39206 = iargs[2];
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.39206->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  D.39206 = iargs[2];
                  bblock.113->last_ins = D.39206;
                  goto <D.39215>;
                  <D.39214>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  D.39206 = iargs[2];
                  bblock.113->last_ins = D.39206;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.39215>:
                  ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper, &iargs);
                  <D.39204>:
                  D.30941 = cfg->mempool;
                  addr = mono_mempool_alloc (D.30941, 80);
                  addr->data.op[1].const_val = 0;
                  D.39216 = addr->data.op[1].const_val;
                  addr->data.op[0].const_val = D.39216;
                  addr->prev = 0B;
                  D.39217 = addr->prev;
                  addr->next = D.39217;
                  addr->opcode = 314;
                  addr->flags = 0;
                  addr->type = 0;
                  addr->dreg = -1;
                  addr->sreg3 = -1;
                  D.39218 = addr->sreg3;
                  addr->sreg2 = D.39218;
                  D.39219 = addr->sreg2;
                  addr->sreg1 = D.39219;
                  D.31162 = cfg->ip;
                  addr->cil_code = D.31162;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  addr->data.op[0].p = D.39224;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39225 = D.39224->flags;
                  D.39226 = D.39225 | 16;
                  D.39224->flags = D.39226;
                  addr->type = 5;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39227 = D.39224->klass;
                  addr->klass = D.39227;
                  D.39228 = alloc_dreg (cfg, 5);
                  D.39229 = (int) D.39228;
                  addr->dreg = D.39229;
                  cfg->has_indirection = 1;
                  D.31089 = cfg->gsharedvt;
                  D.32043 = D.31089 != 0;
                  D.32044 = (long int) D.32043;
                  D.32045 = __builtin_expect (D.32044, 0);
                  if (D.32045 != 0) goto <D.39230>; else goto <D.39231>;
                  <D.39230>:
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39232 = D.39224->data.op[1].vtype;
                  D.39233 = mini_is_gsharedvt_variable_type (cfg, D.39232);
                  if (D.39233 != 0) goto <D.39234>; else goto <D.39235>;
                  <D.39234>:
                  handle_gsharedvt_ldaddr (cfg);
                  <D.39235>:
                  <D.39231>:
                  if (0 != 0) goto <D.39236>; else goto <D.39237>;
                  <D.39236>:
                  {
                    struct MonoInst * var1;
                    struct MonoInst * var2;

                    D.31695 = cfg->varinfo;
                    D.39220 = vtvar->data.op[0].const_val;
                    D.39221 = (long unsigned int) D.39220;
                    D.39222 = D.39221 * 8;
                    D.39223 = D.31695 + D.39222;
                    D.39224 = *D.39223;
                    D.39239 = D.39224->dreg;
                    D.39240 = D.39239 + 1;
                    D.39241 = (unsigned int) D.39240;
                    D.32058 = cfg->vreg_to_inst_len;
                    if (D.39241 < D.32058) goto <D.39242>; else goto <D.39243>;
                    <D.39242>:
                    D.32061 = cfg->vreg_to_inst;
                    D.31695 = cfg->varinfo;
                    D.39220 = vtvar->data.op[0].const_val;
                    D.39221 = (long unsigned int) D.39220;
                    D.39222 = D.39221 * 8;
                    D.39223 = D.31695 + D.39222;
                    D.39224 = *D.39223;
                    D.39239 = D.39224->dreg;
                    D.39244 = (sizetype) D.39239;
                    D.39245 = D.39244 + 1;
                    D.39246 = D.39245 * 8;
                    D.39247 = D.32061 + D.39246;
                    iftmp.272 = *D.39247;
                    goto <D.39248>;
                    <D.39243>:
                    iftmp.272 = 0B;
                    <D.39248>:
                    var1 = iftmp.272;
                    D.31695 = cfg->varinfo;
                    D.39220 = vtvar->data.op[0].const_val;
                    D.39221 = (long unsigned int) D.39220;
                    D.39222 = D.39221 * 8;
                    D.39223 = D.31695 + D.39222;
                    D.39224 = *D.39223;
                    D.39239 = D.39224->dreg;
                    D.39250 = D.39239 + 2;
                    D.39251 = (unsigned int) D.39250;
                    D.32058 = cfg->vreg_to_inst_len;
                    if (D.39251 < D.32058) goto <D.39252>; else goto <D.39253>;
                    <D.39252>:
                    D.32061 = cfg->vreg_to_inst;
                    D.31695 = cfg->varinfo;
                    D.39220 = vtvar->data.op[0].const_val;
                    D.39221 = (long unsigned int) D.39220;
                    D.39222 = D.39221 * 8;
                    D.39223 = D.31695 + D.39222;
                    D.39224 = *D.39223;
                    D.39239 = D.39224->dreg;
                    D.39244 = (sizetype) D.39239;
                    D.39254 = D.39244 + 2;
                    D.39255 = D.39254 * 8;
                    D.39256 = D.32061 + D.39255;
                    iftmp.273 = *D.39256;
                    goto <D.39257>;
                    <D.39253>:
                    iftmp.273 = 0B;
                    <D.39257>:
                    var2 = iftmp.273;
                    D.39258 = var1 == 0B;
                    D.39259 = (long int) D.39258;
                    D.39260 = __builtin_expect (D.39259, 0);
                    if (D.39260 != 0) goto <D.39261>; else goto <D.39262>;
                    <D.39261>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10818, "var1");
                    <D.39262>:
                    D.39263 = var2 == 0B;
                    D.39264 = (long int) D.39263;
                    D.39265 = __builtin_expect (D.39264, 0);
                    if (D.39265 != 0) goto <D.39266>; else goto <D.39267>;
                    <D.39266>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10818, "var2");
                    <D.39267>:
                    D.39268 = var1->flags;
                    D.39269 = D.39268 | 16;
                    var1->flags = D.39269;
                    D.39270 = var2->flags;
                    D.39271 = D.39270 | 16;
                    var2->flags = D.39271;
                  }
                  <D.39237>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.39272>; else goto <D.39273>;
                  <D.39272>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = addr;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  addr->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = addr;
                  goto <D.39274>;
                  <D.39273>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = addr;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.39274>:
                  {
                    struct MonoInst * inst;

                    D.30941 = cfg->mempool;
                    inst = mono_mempool_alloc (D.30941, 80);
                    inst->data.op[1].const_val = 0;
                    D.39275 = inst->data.op[1].const_val;
                    inst->data.op[0].const_val = D.39275;
                    inst->prev = 0B;
                    D.39276 = inst->prev;
                    inst->next = D.39276;
                    inst->opcode = 374;
                    inst->flags = 0;
                    inst->type = 0;
                    inst->dreg = -1;
                    inst->sreg3 = -1;
                    D.39277 = inst->sreg3;
                    inst->sreg2 = D.39277;
                    D.39278 = inst->sreg2;
                    inst->sreg1 = D.39278;
                    D.31162 = cfg->ip;
                    inst->cil_code = D.31162;
                    D.31356 = ins->dreg;
                    inst->sreg1 = D.31356;
                    D.39279 = addr->dreg;
                    inst->dreg = D.39279;
                    inst->data.op[0].const_val = 0;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    if (D.31191 != 0B) goto <D.39280>; else goto <D.39281>;
                    <D.39280>:
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    D.31191->next = inst;
                    bblock.113 = cfg->cbb;
                    D.31191 = bblock.113->last_ins;
                    inst->prev = D.31191;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = inst;
                    goto <D.39282>;
                    <D.39281>:
                    bblock.113 = cfg->cbb;
                    bblock.113 = cfg->cbb;
                    bblock.113->last_ins = inst;
                    D.31191 = bblock.113->last_ins;
                    bblock.113->code = D.31191;
                    <D.39282>:
                  }
                  D.30941 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30941, 80);
                  ins->data.op[1].const_val = 0;
                  D.31158 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.31158;
                  ins->prev = 0B;
                  D.31159 = ins->prev;
                  ins->next = D.31159;
                  ins->opcode = 424;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.31160 = ins->sreg3;
                  ins->sreg2 = D.31160;
                  D.31161 = ins->sreg2;
                  ins->sreg1 = D.31161;
                  D.31162 = cfg->ip;
                  ins->cil_code = D.31162;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39232 = D.39224->data.op[1].vtype;
                  D.39283 = mono_type_to_regmove (cfg, D.39232);
                  D.39284 = (short unsigned int) D.39283;
                  ins->opcode = D.39284;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39232 = D.39224->data.op[1].vtype;
                  type_to_eval_stack_type (cfg, D.39232, ins);
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39227 = D.39224->klass;
                  ins->klass = D.39227;
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39239 = D.39224->dreg;
                  ins->sreg1 = D.39239;
                  D.31705 = ins->type;
                  D.31706 = (<unnamed type>) D.31705;
                  D.39285 = alloc_dreg (cfg, D.31706);
                  D.39286 = (int) D.39285;
                  ins->dreg = D.39286;
                  D.31709 = ins->opcode;
                  if (D.31709 == 427) goto <D.39287>; else goto <D.39288>;
                  <D.39287>:
                  D.31695 = cfg->varinfo;
                  D.39220 = vtvar->data.op[0].const_val;
                  D.39221 = (long unsigned int) D.39220;
                  D.39222 = D.39221 * 8;
                  D.39223 = D.31695 + D.39222;
                  D.39224 = *D.39223;
                  D.39232 = D.39224->data.op[1].vtype;
                  D.39289 = mono_class_from_mono_type (D.39232);
                  ins->klass = D.39289;
                  <D.39288>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.39290>; else goto <D.39291>;
                  <D.39290>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = ins;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  ins->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  goto <D.39292>;
                  <D.39291>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = ins;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.39292>:
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            goto <D.39161>;
            <D.39160>:
            D.32381 = ip + 5;
            if (D.32381 < end) goto <D.39296>; else goto <D.39293>;
            <D.39296>:
            bblock.70 = bblock;
            D.33876 = ip + 5;
            D.39297 = ip_in_bb (cfg, bblock.70, D.33876);
            if (D.39297 != 0) goto <D.39298>; else goto <D.39293>;
            <D.39298>:
            D.32381 = ip + 5;
            D.32923 = *D.32381;
            if (D.32923 == 40) goto <D.39294>; else goto <D.39299>;
            <D.39299>:
            D.32381 = ip + 5;
            D.32923 = *D.32381;
            if (D.32923 == 111) goto <D.39294>; else goto <D.39293>;
            <D.39294>:
            D.35745 = ip + 6;
            D.35746 = *D.35745;
            cmethod = mini_get_method (cfg, method, D.35746, 0B, generic_context);
            if (cmethod != 0B) goto <D.39300>; else goto <D.39293>;
            <D.39300>:
            D.32828 = cmethod->klass;
            D.39301 = mono_defaults.systemtype_class;
            if (D.32828 == D.39301) goto <D.39302>; else goto <D.39293>;
            <D.39302>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 17;
              if (__s2_len <= 3) goto <D.39304>; else goto <D.39305>;
              <D.39304>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = cmethod->name;
                D.39306 = "GetTypeFromHandle";
                D.39307 = MEM[(const unsigned char *)D.39306];
                D.39308 = (int) D.39307;
                D.39309 = *__s2;
                D.39310 = (int) D.39309;
                __result = D.39308 - D.39310;
                {
                  if (__s2_len != 0) goto <D.39311>; else goto <D.39312>;
                  <D.39311>:
                  if (__result == 0) goto <D.39313>; else goto <D.39314>;
                  <D.39313>:
                  D.39315 = &MEM[(void *)"GetTypeFromHandle" + 1B];
                  D.39316 = *D.39315;
                  D.39317 = (int) D.39316;
                  D.39318 = __s2 + 1;
                  D.39319 = *D.39318;
                  D.39320 = (int) D.39319;
                  __result = D.39317 - D.39320;
                  if (__s2_len > 1) goto <D.39321>; else goto <D.39322>;
                  <D.39321>:
                  if (__result == 0) goto <D.39323>; else goto <D.39324>;
                  <D.39323>:
                  D.39325 = &MEM[(void *)"GetTypeFromHandle" + 2B];
                  D.39326 = *D.39325;
                  D.39327 = (int) D.39326;
                  D.39328 = __s2 + 2;
                  D.39329 = *D.39328;
                  D.39330 = (int) D.39329;
                  __result = D.39327 - D.39330;
                  if (__s2_len > 2) goto <D.39331>; else goto <D.39332>;
                  <D.39331>:
                  if (__result == 0) goto <D.39333>; else goto <D.39334>;
                  <D.39333>:
                  D.39335 = &MEM[(void *)"GetTypeFromHandle" + 3B];
                  D.39336 = *D.39335;
                  D.39337 = (int) D.39336;
                  D.39338 = __s2 + 3;
                  D.39339 = *D.39338;
                  D.39340 = (int) D.39339;
                  __result = D.39337 - D.39340;
                  <D.39334>:
                  <D.39332>:
                  <D.39324>:
                  <D.39322>:
                  <D.39314>:
                  <D.39312>:
                }
                D.28568 = __result;
              }
              iftmp.274 = -D.28568;
              goto <D.39341>;
              <D.39305>:
              D.33344 = cmethod->name;
              iftmp.274 = __builtin_strcmp (D.33344, "GetTypeFromHandle");
              <D.39341>:
              D.28569 = iftmp.274;
            }
            if (D.28569 == 0) goto <D.39342>; else goto <D.39293>;
            <D.39342>:
            {
              struct MonoClass * tclass;

              tclass = mono_class_from_mono_type (handle);
              mono_class_init (tclass);
              if (context_used != 0) goto <D.39343>; else goto <D.39344>;
              <D.39343>:
              ins = emit_get_rgctx_klass (cfg, context_used, tclass, 4);
              goto <D.39345>;
              <D.39344>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.39346>; else goto <D.39347>;
              <D.39346>:
              D.30883 = BIT_FIELD_REF <*method, 64, 256>;
              D.30884 = D.30883 & 124;
              if (D.30884 != 0) goto <D.39348>; else goto <D.39349>;
              <D.39348>:
              D.39352 = tclass->image;
              D.39353 = tclass->type_token;
              D.39354 = mono_class_get (D.39352, D.39353);
              if (D.39354 == tclass) goto <D.39355>; else goto <D.39350>;
              <D.39355>:
              if (generic_context == 0B) goto <D.39356>; else goto <D.39350>;
              <D.39356>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                D.30941 = cfg->mempool;
                ins = mono_mempool_alloc (D.30941, 80);
                ins->data.op[1].const_val = 0;
                D.31158 = ins->data.op[1].const_val;
                ins->data.op[0].const_val = D.31158;
                ins->prev = 0B;
                D.31159 = ins->prev;
                ins->next = D.31159;
                ins->opcode = 734;
                ins->flags = 0;
                ins->type = 0;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.31160 = ins->sreg3;
                ins->sreg2 = D.31160;
                D.31161 = ins->sreg2;
                ins->sreg1 = D.31161;
                D.31162 = cfg->ip;
                ins->cil_code = D.31162;
                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.39357 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.39357;
                group->prev = 0B;
                D.39358 = group->prev;
                group->next = D.39358;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.39359 = group->sreg3;
                group->sreg2 = D.39359;
                D.39360 = group->sreg2;
                group->sreg1 = D.39360;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = 0B;
                group->data.op[1].src = 19B;
                D.30941 = cfg->mempool;
                D.39352 = tclass->image;
                D.39353 = tclass->type_token;
                D.39361 = mono_jump_info_token_new2 (D.30941, D.39352, D.39353, generic_context);
                group->data.op[0].p = D.39361;
                D.39362 = got_loc->dreg;
                ins->sreg1 = D.39362;
                ins->data.op[1].p = group;
                ins->type = 6;
                D.39363 = mono_defaults.monotype_class;
                ins->klass = D.39363;
                D.39364 = alloc_dreg (cfg, 6);
                D.39365 = (int) D.39364;
                ins->dreg = D.39365;
              }
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39366>; else goto <D.39367>;
              <D.39366>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39368>;
              <D.39367>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39368>:
              goto <D.39351>;
              <D.39350>:
              D.31021 = cfg->verbose_level;
              if (D.31021 > 1) goto <D.39369>; else goto <D.39370>;
              <D.39369>:
              printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 10842);
              <D.39370>:
              cfg->disable_aot = 1;
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              ins->data.op[0].p = 0B;
              ins->type = 3;
              D.39371 = alloc_dreg (cfg, 3);
              D.39372 = (int) D.39371;
              ins->dreg = D.39372;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39373>; else goto <D.39374>;
              <D.39373>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39375>;
              <D.39374>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39375>:
              <D.39351>:
              goto <D.39376>;
              <D.39349>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                D.30941 = cfg->mempool;
                ins = mono_mempool_alloc (D.30941, 80);
                ins->data.op[1].const_val = 0;
                D.31158 = ins->data.op[1].const_val;
                ins->data.op[0].const_val = D.31158;
                ins->prev = 0B;
                D.31159 = ins->prev;
                ins->next = D.31159;
                ins->opcode = 734;
                ins->flags = 0;
                ins->type = 0;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.31160 = ins->sreg3;
                ins->sreg2 = D.31160;
                D.31161 = ins->sreg2;
                ins->sreg1 = D.31161;
                D.31162 = cfg->ip;
                ins->cil_code = D.31162;
                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.39377 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.39377;
                group->prev = 0B;
                D.39378 = group->prev;
                group->next = D.39378;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.39379 = group->sreg3;
                group->sreg2 = D.39379;
                D.39380 = group->sreg2;
                group->sreg1 = D.39380;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = 0B;
                group->data.op[1].src = 19B;
                D.30941 = cfg->mempool;
                n.161 = (unsigned int) n;
                D.39381 = mono_jump_info_token_new2 (D.30941, image, n.161, generic_context);
                group->data.op[0].p = D.39381;
                D.39382 = got_loc->dreg;
                ins->sreg1 = D.39382;
                ins->data.op[1].p = group;
                ins->type = 6;
                D.39363 = mono_defaults.monotype_class;
                ins->klass = D.39363;
                D.39383 = alloc_dreg (cfg, 6);
                D.39384 = (int) D.39383;
                ins->dreg = D.39384;
              }
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39385>; else goto <D.39386>;
              <D.39385>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39387>;
              <D.39386>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39387>:
              <D.39376>:
              goto <D.39388>;
              <D.39347>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              D.30966 = cfg->domain;
              D.39389 = mono_type_get_object (D.30966, handle);
              ins->data.op[0].p = D.39389;
              ins->type = 3;
              D.39390 = alloc_dreg (cfg, 3);
              D.39391 = (int) D.39390;
              ins->dreg = D.39391;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39392>; else goto <D.39393>;
              <D.39392>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39394>;
              <D.39393>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39394>:
              <D.39388>:
              <D.39345>:
              ins->type = 6;
              D.32828 = cmethod->klass;
              ins->klass = D.32828;
              ip = ip + 5;
            }
            goto <D.39295>;
            <D.39293>:
            {
              struct MonoInst * addr;
              struct MonoInst * vtvar;

              handle_class.270 = handle_class;
              D.39165 = &handle_class.270->byval_arg;
              vtvar = mono_compile_create_var (cfg, D.39165, 329);
              if (context_used != 0) goto <D.39395>; else goto <D.39396>;
              <D.39395>:
              D.39126 = mono_defaults.typehandle_class;
              handle_class.270 = handle_class;
              if (D.39126 == handle_class.270) goto <D.39397>; else goto <D.39398>;
              <D.39397>:
              D.39399 = mono_class_from_mono_type (handle);
              ins = emit_get_rgctx_klass (cfg, context_used, D.39399, 3);
              goto <D.39400>;
              <D.39398>:
              D.39156 = mono_defaults.methodhandle_class;
              handle_class.270 = handle_class;
              if (D.39156 == handle_class.270) goto <D.39401>; else goto <D.39402>;
              <D.39401>:
              ins = emit_get_rgctx_method (cfg, context_used, handle, 5);
              goto <D.39403>;
              <D.39402>:
              D.39151 = mono_defaults.fieldhandle_class;
              handle_class.270 = handle_class;
              if (D.39151 == handle_class.270) goto <D.39404>; else goto <D.39405>;
              <D.39404>:
              ins = emit_get_rgctx_field (cfg, context_used, handle, 7);
              goto <D.39406>;
              <D.39405>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10871);
              <D.39406>:
              <D.39403>:
              <D.39400>:
              goto <D.39407>;
              <D.39396>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.31337 = D.31336 & 274877906944;
              if (D.31337 != 0) goto <D.39408>; else goto <D.39409>;
              <D.39408>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                D.30941 = cfg->mempool;
                ins = mono_mempool_alloc (D.30941, 80);
                ins->data.op[1].const_val = 0;
                D.31158 = ins->data.op[1].const_val;
                ins->data.op[0].const_val = D.31158;
                ins->prev = 0B;
                D.31159 = ins->prev;
                ins->next = D.31159;
                ins->opcode = 734;
                ins->flags = 0;
                ins->type = 0;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.31160 = ins->sreg3;
                ins->sreg2 = D.31160;
                D.31161 = ins->sreg2;
                ins->sreg1 = D.31161;
                D.31162 = cfg->ip;
                ins->cil_code = D.31162;
                got_loc = mono_get_got_var (cfg);
                D.30941 = cfg->mempool;
                group = mono_mempool_alloc (D.30941, 80);
                group->data.op[1].const_val = 0;
                D.39410 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.39410;
                group->prev = 0B;
                D.39411 = group->prev;
                group->next = D.39411;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.39412 = group->sreg3;
                group->sreg2 = D.39412;
                D.39413 = group->sreg2;
                group->sreg1 = D.39413;
                D.31162 = cfg->ip;
                group->cil_code = D.31162;
                group->data.op[0].src = 0B;
                group->data.op[1].src = 18B;
                D.30941 = cfg->mempool;
                n.161 = (unsigned int) n;
                D.39414 = mono_jump_info_token_new2 (D.30941, image, n.161, generic_context);
                group->data.op[0].p = D.39414;
                D.39415 = got_loc->dreg;
                ins->sreg1 = D.39415;
                ins->data.op[1].p = group;
                ins->type = 3;
                ins->klass = 0B;
                D.39416 = alloc_dreg (cfg, 3);
                D.39417 = (int) D.39416;
                ins->dreg = D.39417;
              }
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39418>; else goto <D.39419>;
              <D.39418>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39420>;
              <D.39419>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39420>:
              goto <D.39421>;
              <D.39409>:
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              ins->data.op[0].p = handle;
              ins->type = 3;
              D.39422 = alloc_dreg (cfg, 3);
              D.39423 = (int) D.39422;
              ins->dreg = D.39423;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39424>; else goto <D.39425>;
              <D.39424>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39426>;
              <D.39425>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39426>:
              <D.39421>:
              <D.39407>:
              D.30941 = cfg->mempool;
              addr = mono_mempool_alloc (D.30941, 80);
              addr->data.op[1].const_val = 0;
              D.39427 = addr->data.op[1].const_val;
              addr->data.op[0].const_val = D.39427;
              addr->prev = 0B;
              D.39428 = addr->prev;
              addr->next = D.39428;
              addr->opcode = 314;
              addr->flags = 0;
              addr->type = 0;
              addr->dreg = -1;
              addr->sreg3 = -1;
              D.39429 = addr->sreg3;
              addr->sreg2 = D.39429;
              D.39430 = addr->sreg2;
              addr->sreg1 = D.39430;
              D.31162 = cfg->ip;
              addr->cil_code = D.31162;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              addr->data.op[0].p = D.39435;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39436 = D.39435->flags;
              D.39437 = D.39436 | 16;
              D.39435->flags = D.39437;
              addr->type = 5;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39438 = D.39435->klass;
              addr->klass = D.39438;
              D.39439 = alloc_dreg (cfg, 5);
              D.39440 = (int) D.39439;
              addr->dreg = D.39440;
              cfg->has_indirection = 1;
              D.31089 = cfg->gsharedvt;
              D.32043 = D.31089 != 0;
              D.32044 = (long int) D.32043;
              D.32045 = __builtin_expect (D.32044, 0);
              if (D.32045 != 0) goto <D.39441>; else goto <D.39442>;
              <D.39441>:
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39443 = D.39435->data.op[1].vtype;
              D.39444 = mini_is_gsharedvt_variable_type (cfg, D.39443);
              if (D.39444 != 0) goto <D.39445>; else goto <D.39446>;
              <D.39445>:
              handle_gsharedvt_ldaddr (cfg);
              <D.39446>:
              <D.39442>:
              if (0 != 0) goto <D.39447>; else goto <D.39448>;
              <D.39447>:
              {
                struct MonoInst * var1;
                struct MonoInst * var2;

                D.31695 = cfg->varinfo;
                D.39431 = vtvar->data.op[0].const_val;
                D.39432 = (long unsigned int) D.39431;
                D.39433 = D.39432 * 8;
                D.39434 = D.31695 + D.39433;
                D.39435 = *D.39434;
                D.39450 = D.39435->dreg;
                D.39451 = D.39450 + 1;
                D.39452 = (unsigned int) D.39451;
                D.32058 = cfg->vreg_to_inst_len;
                if (D.39452 < D.32058) goto <D.39453>; else goto <D.39454>;
                <D.39453>:
                D.32061 = cfg->vreg_to_inst;
                D.31695 = cfg->varinfo;
                D.39431 = vtvar->data.op[0].const_val;
                D.39432 = (long unsigned int) D.39431;
                D.39433 = D.39432 * 8;
                D.39434 = D.31695 + D.39433;
                D.39435 = *D.39434;
                D.39450 = D.39435->dreg;
                D.39455 = (sizetype) D.39450;
                D.39456 = D.39455 + 1;
                D.39457 = D.39456 * 8;
                D.39458 = D.32061 + D.39457;
                iftmp.275 = *D.39458;
                goto <D.39459>;
                <D.39454>:
                iftmp.275 = 0B;
                <D.39459>:
                var1 = iftmp.275;
                D.31695 = cfg->varinfo;
                D.39431 = vtvar->data.op[0].const_val;
                D.39432 = (long unsigned int) D.39431;
                D.39433 = D.39432 * 8;
                D.39434 = D.31695 + D.39433;
                D.39435 = *D.39434;
                D.39450 = D.39435->dreg;
                D.39461 = D.39450 + 2;
                D.39462 = (unsigned int) D.39461;
                D.32058 = cfg->vreg_to_inst_len;
                if (D.39462 < D.32058) goto <D.39463>; else goto <D.39464>;
                <D.39463>:
                D.32061 = cfg->vreg_to_inst;
                D.31695 = cfg->varinfo;
                D.39431 = vtvar->data.op[0].const_val;
                D.39432 = (long unsigned int) D.39431;
                D.39433 = D.39432 * 8;
                D.39434 = D.31695 + D.39433;
                D.39435 = *D.39434;
                D.39450 = D.39435->dreg;
                D.39455 = (sizetype) D.39450;
                D.39465 = D.39455 + 2;
                D.39466 = D.39465 * 8;
                D.39467 = D.32061 + D.39466;
                iftmp.276 = *D.39467;
                goto <D.39468>;
                <D.39464>:
                iftmp.276 = 0B;
                <D.39468>:
                var2 = iftmp.276;
                D.39469 = var1 == 0B;
                D.39470 = (long int) D.39469;
                D.39471 = __builtin_expect (D.39470, 0);
                if (D.39471 != 0) goto <D.39472>; else goto <D.39473>;
                <D.39472>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10878, "var1");
                <D.39473>:
                D.39474 = var2 == 0B;
                D.39475 = (long int) D.39474;
                D.39476 = __builtin_expect (D.39475, 0);
                if (D.39476 != 0) goto <D.39477>; else goto <D.39478>;
                <D.39477>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10878, "var2");
                <D.39478>:
                D.39479 = var1->flags;
                D.39480 = D.39479 | 16;
                var1->flags = D.39480;
                D.39481 = var2->flags;
                D.39482 = D.39481 | 16;
                var2->flags = D.39482;
              }
              <D.39448>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39483>; else goto <D.39484>;
              <D.39483>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = addr;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              addr->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = addr;
              goto <D.39485>;
              <D.39484>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = addr;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39485>:
              {
                struct MonoInst * inst;

                D.30941 = cfg->mempool;
                inst = mono_mempool_alloc (D.30941, 80);
                inst->data.op[1].const_val = 0;
                D.39486 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.39486;
                inst->prev = 0B;
                D.39487 = inst->prev;
                inst->next = D.39487;
                inst->opcode = 374;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.39488 = inst->sreg3;
                inst->sreg2 = D.39488;
                D.39489 = inst->sreg2;
                inst->sreg1 = D.39489;
                D.31162 = cfg->ip;
                inst->cil_code = D.31162;
                D.31356 = ins->dreg;
                inst->sreg1 = D.31356;
                D.39490 = addr->dreg;
                inst->dreg = D.39490;
                inst->data.op[0].const_val = 0;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                if (D.31191 != 0B) goto <D.39491>; else goto <D.39492>;
                <D.39491>:
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                D.31191->next = inst;
                bblock.113 = cfg->cbb;
                D.31191 = bblock.113->last_ins;
                inst->prev = D.31191;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                goto <D.39493>;
                <D.39492>:
                bblock.113 = cfg->cbb;
                bblock.113 = cfg->cbb;
                bblock.113->last_ins = inst;
                D.31191 = bblock.113->last_ins;
                bblock.113->code = D.31191;
                <D.39493>:
              }
              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.31158 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.31158;
              ins->prev = 0B;
              D.31159 = ins->prev;
              ins->next = D.31159;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.31160 = ins->sreg3;
              ins->sreg2 = D.31160;
              D.31161 = ins->sreg2;
              ins->sreg1 = D.31161;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39443 = D.39435->data.op[1].vtype;
              D.39494 = mono_type_to_regmove (cfg, D.39443);
              D.39495 = (short unsigned int) D.39494;
              ins->opcode = D.39495;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39443 = D.39435->data.op[1].vtype;
              type_to_eval_stack_type (cfg, D.39443, ins);
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39438 = D.39435->klass;
              ins->klass = D.39438;
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39450 = D.39435->dreg;
              ins->sreg1 = D.39450;
              D.31705 = ins->type;
              D.31706 = (<unnamed type>) D.31705;
              D.39496 = alloc_dreg (cfg, D.31706);
              D.39497 = (int) D.39496;
              ins->dreg = D.39497;
              D.31709 = ins->opcode;
              if (D.31709 == 427) goto <D.39498>; else goto <D.39499>;
              <D.39498>:
              D.31695 = cfg->varinfo;
              D.39431 = vtvar->data.op[0].const_val;
              D.39432 = (long unsigned int) D.39431;
              D.39433 = D.39432 * 8;
              D.39434 = D.31695 + D.39433;
              D.39435 = *D.39434;
              D.39443 = D.39435->data.op[1].vtype;
              D.39500 = mono_class_from_mono_type (D.39443);
              ins->klass = D.39500;
              <D.39499>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39501>; else goto <D.39502>;
              <D.39501>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39503>;
              <D.39502>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39503>:
            }
            <D.39295>:
            <D.39161>:
            sp.277 = sp;
            sp = sp.277 + 8;
            *sp.277 = ins;
            ip = ip + 5;
            goto <D.27857>;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      <D.28582>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.39505>; else goto <D.39506>;
      <D.39505>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.39507>; else goto <D.39508>;
      <D.39507>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.39509>; else goto <D.39510>;
      <D.39509>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39510>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39508>:
      D.39511 = mini_get_debug_options ();
      D.39512 = D.39511->break_on_unverified;
      if (D.39512 != 0) goto <D.39513>; else goto unverified;
      <D.39513>:
      raise (5);
      <D.39506>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 371;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      sp = sp + 18446744073709551608;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ip = ip + 1;
      bblock.70 = bblock;
      bblock.70->out_of_line = 1;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.39514>; else goto <D.39515>;
      <D.39514>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.39516>;
      <D.39515>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.39516>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 798;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.39517>; else goto <D.39518>;
      <D.39517>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.39519>;
      <D.39518>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.39519>:
      sp = stack_start;
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, end_bblock);
      start_new_bblock = 1;
      goto <D.27857>;
      <D.28583>:
      if (sp != stack_start) goto <D.39520>; else goto <D.39521>;
      <D.39520>:
      emit_seq_point (cfg, method, ip, 0, 0);
      <D.39521>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 738;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.39522>; else goto <D.39523>;
      <D.39522>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.39524>;
      <D.39523>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.39524>:
      ip = ip + 1;
      start_new_bblock = 1;
      goto <D.28585>;
      <D.28584>:
      sp = sp + 18446744073709551608;
      <D.28585>:
      if (sp != stack_start) goto <D.28584>; else goto <D.28586>;
      <D.28586>:
      goto <D.27857>;
      <D.28587>:
      <D.28588>:
      {
        struct GList * handlers;

        D.31838 = *ip;
        if (D.31838 == 221) goto <D.39525>; else goto <D.39526>;
        <D.39525>:
        D.32381 = ip + 5;
        if (D.32381 > end) goto <D.39527>; else goto <D.39528>;
        <D.39527>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39529>; else goto <D.39530>;
        <D.39529>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39531>; else goto <D.39532>;
        <D.39531>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39532>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39530>:
        D.39533 = mini_get_debug_options ();
        D.39534 = D.39533->break_on_unverified;
        if (D.39534 != 0) goto <D.39535>; else goto unverified;
        <D.39535>:
        raise (5);
        <D.39528>:
        D.32400 = ip + 1;
        D.32401 = *D.32400;
        D.32402 = (int) D.32401;
        D.39536 = (sizetype) D.32402;
        D.39537 = D.39536 + 5;
        target = ip + D.39537;
        goto <D.39538>;
        <D.39526>:
        D.31968 = ip + 2;
        if (D.31968 > end) goto <D.39539>; else goto <D.39540>;
        <D.39539>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39541>; else goto <D.39542>;
        <D.39541>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39543>; else goto <D.39544>;
        <D.39543>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39544>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39542>:
        D.39545 = mini_get_debug_options ();
        D.39546 = D.39545->break_on_unverified;
        if (D.39546 != 0) goto <D.39547>; else goto unverified;
        <D.39547>:
        raise (5);
        <D.39540>:
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.39548 = (signed char) D.31988;
        D.39549 = (sizetype) D.39548;
        D.39550 = D.39549 + 2;
        target = ip + D.39550;
        <D.39538>:
        goto <D.28591>;
        <D.28590>:
        sp = sp + 18446744073709551608;
        <D.28591>:
        if (sp != stack_start) goto <D.28590>; else goto <D.28592>;
        <D.28592>:
        i = 0;
        goto <D.28601>;
        <D.28600>:
        {
          struct MonoExceptionClause * clause;

          D.31068 = header->clauses;
          D.31069 = (long unsigned int) i;
          D.31070 = D.31069 * 32;
          clause = D.31068 + D.31070;
          D.39551 = clause->handler_offset;
          D.39552 = (long int) D.39551;
          ip.75 = (long int) ip;
          D.31088 = header->code;
          D.31650 = (long int) D.31088;
          D.31651 = ip.75 - D.31650;
          if (D.39552 <= D.31651) goto <D.39553>; else goto <D.39554>;
          <D.39553>:
          ip.75 = (long int) ip;
          D.31088 = header->code;
          D.31650 = (long int) D.31088;
          D.31651 = ip.75 - D.31650;
          D.39551 = clause->handler_offset;
          D.39555 = clause->handler_len;
          D.39556 = D.39551 + D.39555;
          D.39557 = (long int) D.39556;
          if (D.31651 < D.39557) goto <D.39558>; else goto <D.39559>;
          <D.39558>:
          D.39560 = clause->flags;
          if (D.39560 == 0) goto <D.39561>; else goto <D.39562>;
          <D.39561>:
          ip.75 = (long int) ip;
          D.31088 = header->code;
          D.31650 = (long int) D.31088;
          D.31651 = ip.75 - D.31650;
          D.31838 = *ip;
          if (D.31838 == 221) goto <D.39564>; else goto <D.39565>;
          <D.39564>:
          iftmp.278 = 5;
          goto <D.39566>;
          <D.39565>:
          iftmp.278 = 2;
          <D.39566>:
          D.39567 = D.31651 + iftmp.278;
          D.39551 = clause->handler_offset;
          D.39555 = clause->handler_len;
          D.39556 = D.39551 + D.39555;
          D.39557 = (long int) D.39556;
          if (D.39567 <= D.39557) goto <D.39568>; else goto <D.39569>;
          <D.39568>:
          D.30883 = BIT_FIELD_REF <*method, 64, 256>;
          D.30884 = D.30883 & 124;
          if (D.30884 != 16) goto <D.39570>; else goto <D.39571>;
          <D.39570>:
          {
            struct MonoInst * exc_ins;
            struct MonoBasicBlock * dont_throw;

            exc_ins = mono_emit_jit_icall (cfg, mono_thread_get_undeniable_exception, 0B);
            D.30941 = cfg->mempool;
            dont_throw = mono_mempool_alloc0 (D.30941, 296);
            D.31048 = cfg->num_bblocks;
            D.39572 = D.31048;
            D.39573 = D.39572 + 1;
            cfg->num_bblocks = D.39573;
            D.39574 = (int) D.39572;
            dont_throw->block_num = D.39574;
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.39575 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39575;
              inst->prev = 0B;
              D.39576 = inst->prev;
              inst->next = D.39576;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39577 = inst->sreg3;
              inst->sreg2 = D.39577;
              D.39578 = inst->sreg2;
              inst->sreg1 = D.39578;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.39579 = exc_ins->dreg;
              inst->sreg1 = D.39579;
              inst->data.op[1].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39580>; else goto <D.39581>;
              <D.39580>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.39582>;
              <D.39581>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39582>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.39583 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.39583;
              ins->prev = 0B;
              D.39584 = ins->prev;
              ins->next = D.39584;
              ins->opcode = 551;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.39585 = ins->sreg3;
              ins->sreg2 = D.39585;
              D.39586 = ins->sreg2;
              ins->sreg1 = D.39586;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              if (0 != 0) goto <D.39587>; else goto <D.39588>;
              <D.39587>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.39589 = D.31048;
              D.39590 = D.39589 + 1;
              cfg->num_bblocks = D.39590;
              D.39591 = (int) D.39589;
              falsebb->block_num = D.39591;
              ins->data.op[0].target_block = dont_throw;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, dont_throw);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39592>; else goto <D.39593>;
              <D.39592>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39594>;
              <D.39593>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39594>:
              D.39595 = falsebb->cil_code;
              if (D.39595 != 0B) goto <D.39596>; else goto <D.39597>;
              <D.39596>:
              D.31071 = cfg->cil_offset_to_bb;
              D.39595 = falsebb->cil_code;
              D.39598 = (long int) D.39595;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.39599 = D.39598 - D.31077;
              D.39600 = (long unsigned int) D.39599;
              D.39601 = D.39600 * 8;
              D.39602 = D.31071 + D.39601;
              *D.39602 = falsebb;
              <D.39597>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39606>; else goto <D.39603>;
              <D.39606>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.39604>; else goto <D.39607>;
              <D.39607>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.39604>; else goto <D.39608>;
              <D.39608>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.39604>; else goto <D.39603>;
              <D.39604>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.39609>; else goto <D.39603>;
              <D.39609>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.39605>;
              <D.39603>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.39610>; else goto <D.39612>;
              <D.39612>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.39613>; else goto <D.39611>;
              <D.39613>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.39614>; else goto <D.39611>;
              <D.39614>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.39615>; else goto <D.39611>;
              <D.39615>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.39616>; else goto <D.39611>;
              <D.39616>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.39610>; else goto <D.39611>;
              <D.39610>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.39611>:
              <D.39605>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39617>;
              <D.39588>:
              D.30941 = cfg->mempool;
              D.39618 = mono_mempool_alloc (D.30941, 16);
              ins->data.op[1].many_blocks = D.39618;
              D.39619 = ins->data.op[1].many_blocks;
              *D.39619 = dont_throw;
              D.39619 = ins->data.op[1].many_blocks;
              D.39620 = D.39619 + 8;
              *D.39620 = 0B;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, dont_throw);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39621>; else goto <D.39622>;
              <D.39621>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.39623>;
              <D.39622>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39623>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.35146 = D.31336 & 34359738368;
              if (D.35146 == 0) goto <D.39624>; else goto <D.39625>;
              <D.39624>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.39626 = D.31048;
              D.39627 = D.39626 + 1;
              cfg->num_bblocks = D.39627;
              D.39628 = (int) D.39626;
              falsebb->block_num = D.39628;
              D.39619 = ins->data.op[1].many_blocks;
              D.39620 = D.39619 + 8;
              *D.39620 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              D.39595 = falsebb->cil_code;
              if (D.39595 != 0B) goto <D.39629>; else goto <D.39630>;
              <D.39629>:
              D.31071 = cfg->cil_offset_to_bb;
              D.39595 = falsebb->cil_code;
              D.39598 = (long int) D.39595;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.39599 = D.39598 - D.31077;
              D.39600 = (long unsigned int) D.39599;
              D.39601 = D.39600 * 8;
              D.39602 = D.31071 + D.39601;
              *D.39602 = falsebb;
              <D.39630>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39634>; else goto <D.39631>;
              <D.39634>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.39632>; else goto <D.39635>;
              <D.39635>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.39632>; else goto <D.39636>;
              <D.39636>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.39632>; else goto <D.39631>;
              <D.39632>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.39637>; else goto <D.39631>;
              <D.39637>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.39633>;
              <D.39631>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.39638>; else goto <D.39640>;
              <D.39640>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.39641>; else goto <D.39639>;
              <D.39641>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.39642>; else goto <D.39639>;
              <D.39642>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.39643>; else goto <D.39639>;
              <D.39643>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.39644>; else goto <D.39639>;
              <D.39644>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.39638>; else goto <D.39639>;
              <D.39638>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.39639>:
              <D.39633>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39645>;
              <D.39625>:
              bblock.113 = cfg->cbb;
              bblock.113->extended = 1;
              <D.39645>:
              <D.39617>:
            }
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.39646 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39646;
              inst->prev = 0B;
              D.39647 = inst->prev;
              inst->next = D.39647;
              inst->opcode = 371;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39648 = inst->sreg3;
              inst->sreg2 = D.39648;
              D.39649 = inst->sreg2;
              inst->sreg1 = D.39649;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.39579 = exc_ins->dreg;
              inst->sreg1 = D.39579;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.39650>; else goto <D.39651>;
              <D.39650>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.39652>;
              <D.39651>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.39652>:
            }
            D.39653 = dont_throw->cil_code;
            if (D.39653 != 0B) goto <D.39654>; else goto <D.39655>;
            <D.39654>:
            D.31071 = cfg->cil_offset_to_bb;
            D.39653 = dont_throw->cil_code;
            D.39656 = (long int) D.39653;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.39657 = D.39656 - D.31077;
            D.39658 = (long unsigned int) D.39657;
            D.39659 = D.39658 * 8;
            D.39660 = D.31071 + D.39659;
            *D.39660 = dont_throw;
            <D.39655>:
            D.31108 = cfg->real_offset;
            dont_throw->real_offset = D.31108;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.39664>; else goto <D.39661>;
            <D.39664>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35123 = D.35122 + 64985;
            if (D.35123 <= 9) goto <D.39662>; else goto <D.39665>;
            <D.39665>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35125 = D.35122 + 64878;
            if (D.35125 <= 9) goto <D.39662>; else goto <D.39666>;
            <D.39666>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35127 = D.35122 + 64888;
            if (D.35127 <= 9) goto <D.39662>; else goto <D.39661>;
            <D.39662>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35128 = D.31191->data.op[1].many_blocks;
            D.35129 = D.35128 + 8;
            D.35130 = *D.35129;
            if (D.35130 == 0B) goto <D.39667>; else goto <D.39661>;
            <D.39667>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35128 = D.31191->data.op[1].many_blocks;
            D.35129 = D.35128 + 8;
            *D.35129 = dont_throw;
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, dont_throw);
            goto <D.39663>;
            <D.39661>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 == 0B) goto <D.39668>; else goto <D.39670>;
            <D.39670>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            if (D.35122 != 442) goto <D.39671>; else goto <D.39669>;
            <D.39671>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            if (D.35122 != 759) goto <D.39672>; else goto <D.39669>;
            <D.39672>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35123 = D.35122 + 64985;
            if (D.35123 > 9) goto <D.39673>; else goto <D.39669>;
            <D.39673>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35125 = D.35122 + 64878;
            if (D.35125 > 9) goto <D.39674>; else goto <D.39669>;
            <D.39674>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35127 = D.35122 + 64888;
            if (D.35127 > 9) goto <D.39668>; else goto <D.39669>;
            <D.39668>:
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, dont_throw);
            <D.39669>:
            <D.39663>:
            bblock.113 = cfg->cbb;
            bblock.113->next_bb = dont_throw;
            cfg->cbb = dont_throw;
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
          }
          <D.39571>:
          <D.39569>:
          <D.39562>:
          <D.39559>:
          <D.39554>:
        }
        i = i + 1;
        <D.28601>:
        D.31257 = header->num_clauses;
        D.31258 = (int) D.31257;
        if (D.31258 > i) goto <D.28600>; else goto <D.28602>;
        <D.28602>:
        handlers = mono_find_final_block (cfg, ip, target, 2);
        if (handlers != 0B) goto <D.39675>; else goto <D.39676>;
        <D.39675>:
        {
          struct GList * tmp;
          struct MonoExceptionClause * clause;

          tmp = handlers;
          goto <D.28607>;
          <D.28606>:
          clause = tmp->data;
          D.31071 = cfg->cil_offset_to_bb;
          D.39677 = clause->handler_offset;
          D.39678 = (long unsigned int) D.39677;
          D.39679 = D.39678 * 8;
          D.39680 = D.31071 + D.39679;
          tblock = *D.39680;
          D.39681 = tblock == 0B;
          D.39682 = (long int) D.39681;
          D.39683 = __builtin_expect (D.39682, 0);
          if (D.39683 != 0) goto <D.39684>; else goto <D.39685>;
          <D.39684>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10988, "tblock");
          <D.39685>:
          bblock.70 = bblock;
          link_bblock (cfg, bblock.70, tblock);
          D.30941 = cfg->mempool;
          ins = mono_mempool_alloc (D.30941, 80);
          ins->data.op[1].const_val = 0;
          D.31158 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.31158;
          ins->prev = 0B;
          D.31159 = ins->prev;
          ins->next = D.31159;
          ins->opcode = 735;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.31160 = ins->sreg3;
          ins->sreg2 = D.31160;
          D.31161 = ins->sreg2;
          ins->sreg1 = D.31161;
          D.31162 = cfg->ip;
          ins->cil_code = D.31162;
          ins->data.op[0].target_block = tblock;
          ins->data.op[1].exception_clause = clause;
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          if (D.31279 != 0B) goto <D.39686>; else goto <D.39687>;
          <D.39686>:
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          D.31279->next = ins;
          bblock.70 = bblock;
          D.31279 = bblock.70->last_ins;
          ins->prev = D.31279;
          bblock.70 = bblock;
          bblock.70->last_ins = ins;
          goto <D.39688>;
          <D.39687>:
          bblock.70 = bblock;
          bblock.70 = bblock;
          bblock.70->last_ins = ins;
          D.31279 = bblock.70->last_ins;
          bblock.70->code = D.31279;
          <D.39688>:
          bblock.70 = bblock;
          bblock.70->has_call_handler = 1;
          if (0 != 0) goto <D.39689>; else goto <D.39690>;
          <D.39689>:
          {
            struct MonoBasicBlock * target_bb;

            D.31071 = cfg->cil_offset_to_bb;
            target.136 = (long int) target;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.34568 = target.136 - D.31077;
            D.34569 = (long unsigned int) D.34568;
            D.34570 = D.34569 * 8;
            D.34571 = D.31071 + D.34570;
            target_bb = *D.34571;
            if (target_bb == 0B) goto <D.39691>; else goto <D.39692>;
            <D.39691>:
            if (target >= end) goto <D.39693>; else goto <D.39695>;
            <D.39695>:
            D.31088 = header->code;
            if (D.31088 > target) goto <D.39693>; else goto <D.39694>;
            <D.39693>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.39696>; else goto <D.39697>;
            <D.39696>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.39698>; else goto <D.39699>;
            <D.39698>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39699>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39697>:
            D.39700 = mini_get_debug_options ();
            D.39701 = D.39700->break_on_unverified;
            if (D.39701 != 0) goto <D.39702>; else goto unverified;
            <D.39702>:
            raise (5);
            <D.39694>:
            D.30941 = cfg->mempool;
            target_bb = mono_mempool_alloc0 (D.30941, 296);
            D.31048 = cfg->num_bblocks;
            D.39703 = D.31048;
            D.39704 = D.39703 + 1;
            cfg->num_bblocks = D.39704;
            D.39705 = (int) D.39703;
            target_bb->block_num = D.39705;
            target_bb->cil_code = target;
            D.39706 = target_bb->cil_code;
            if (D.39706 != 0B) goto <D.39707>; else goto <D.39708>;
            <D.39707>:
            D.31071 = cfg->cil_offset_to_bb;
            D.39706 = target_bb->cil_code;
            D.39709 = (long int) D.39706;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.39710 = D.39709 - D.31077;
            D.39711 = (long unsigned int) D.39710;
            D.39712 = D.39711 * 8;
            D.39713 = D.31071 + D.39712;
            *D.39713 = target_bb;
            <D.39708>:
            D.31108 = cfg->real_offset;
            target_bb->real_offset = D.31108;
            <D.39692>:
            link_bblock (cfg, tblock, target_bb);
          }
          <D.39690>:
          tmp = tmp->next;
          <D.28607>:
          if (tmp != 0B) goto <D.28606>; else goto <D.28608>;
          <D.28608>:
          monoeg_g_list_free (handlers);
        }
        <D.39676>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.39714>; else goto <D.39715>;
        <D.39714>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.39716>;
        <D.39715>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.39716>:
        D.31071 = cfg->cil_offset_to_bb;
        target.136 = (long int) target;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.34568 = target.136 - D.31077;
        D.34569 = (long unsigned int) D.34568;
        D.34570 = D.34569 * 8;
        D.34571 = D.31071 + D.34570;
        tblock = *D.34571;
        if (tblock == 0B) goto <D.39717>; else goto <D.39718>;
        <D.39717>:
        if (target >= end) goto <D.39719>; else goto <D.39721>;
        <D.39721>:
        D.31088 = header->code;
        if (D.31088 > target) goto <D.39719>; else goto <D.39720>;
        <D.39719>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39722>; else goto <D.39723>;
        <D.39722>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39724>; else goto <D.39725>;
        <D.39724>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39725>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39723>:
        D.39726 = mini_get_debug_options ();
        D.39727 = D.39726->break_on_unverified;
        if (D.39727 != 0) goto <D.39728>; else goto unverified;
        <D.39728>:
        raise (5);
        <D.39720>:
        D.30941 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30941, 296);
        D.31048 = cfg->num_bblocks;
        D.39729 = D.31048;
        D.39730 = D.39729 + 1;
        cfg->num_bblocks = D.39730;
        D.39731 = (int) D.39729;
        tblock->block_num = D.39731;
        tblock->cil_code = target;
        D.31138 = tblock->cil_code;
        if (D.31138 != 0B) goto <D.39732>; else goto <D.39733>;
        <D.39732>:
        D.31071 = cfg->cil_offset_to_bb;
        D.31138 = tblock->cil_code;
        D.31141 = (long int) D.31138;
        D.31076 = cfg->cil_start;
        D.31077 = (long int) D.31076;
        D.31142 = D.31141 - D.31077;
        D.31143 = (long unsigned int) D.31142;
        D.31144 = D.31143 * 8;
        D.31145 = D.31071 + D.31144;
        *D.31145 = tblock;
        <D.39733>:
        D.31108 = cfg->real_offset;
        tblock->real_offset = D.31108;
        <D.39718>:
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, tblock);
        ins->data.op[0].target_block = tblock;
        start_new_bblock = 1;
        D.31838 = *ip;
        if (D.31838 == 221) goto <D.39734>; else goto <D.39735>;
        <D.39734>:
        ip = ip + 5;
        goto <D.39736>;
        <D.39735>:
        ip = ip + 2;
        <D.39736>:
        goto <D.27857>;
      }
      <D.28609>:
      D.30883 = BIT_FIELD_REF <*method, 64, 256>;
      D.30884 = D.30883 & 124;
      D.39737 = D.30884 == 0;
      D.39738 = (long int) D.39737;
      D.39739 = __builtin_expect (D.39738, 0);
      if (D.39739 != 0) goto <D.39740>; else goto <D.39741>;
      <D.39740>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11030, "method->wrapper_type != MONO_WRAPPER_NONE");
      <D.39741>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.39742>; else goto <D.39743>;
      <D.39742>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.39744>; else goto <D.39745>;
      <D.39744>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.39746>; else goto <D.39747>;
      <D.39746>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39747>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39745>:
      D.39748 = mini_get_debug_options ();
      D.39749 = D.39748->break_on_unverified;
      if (D.39749 != 0) goto <D.39750>; else goto unverified;
      <D.39750>:
      raise (5);
      <D.39743>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      switch (D.32296) <default: <D.28678>, case 0: <D.28610>, case 1: <D.28639>, case 2: <D.28615>, case 3: <D.28629>, case 4: <D.28634>, case 5: <D.28646>, case 6: <D.28640>, case 7: <D.28649>, case 8: <D.28650>, case 9: <D.28652>, case 10: <D.28653>, case 11: <D.28654>, case 12: <D.28657>, case 13: <D.28658>, case 14: <D.28624>, case 15: <D.28660>, case 16: <D.28662>, case 17: <D.28663>, case 18: <D.28676>, case 19: <D.28619>>
      <D.28610>:
      {
        void * func;
        struct MonoJitICallInfo * info;

        token = MEM[(const guint32 *)ip + 2B];
        func = mono_method_get_wrapper_data (method, token);
        info = mono_find_jit_icall_by_addr (func);
        if (info == 0B) goto <D.39751>; else goto <D.39752>;
        <D.39751>:
        D.39753 = mono_method_full_name (method, 1);
        monoeg_g_log (0B, 4, "Could not find icall address in wrapper %s", D.39753);
        <D.28613>:
        goto <D.28613>;
        <D.39752>:
        D.39754 = info == 0B;
        D.39755 = (long int) D.39754;
        D.39756 = __builtin_expect (D.39755, 0);
        if (D.39756 != 0) goto <D.39757>; else goto <D.39758>;
        <D.39757>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11043, "info");
        <D.39758>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.39759 = info->sig;
        D.39760 = D.39759->param_count;
        D.39761 = (long int) D.39760;
        if (D.31731 < D.39761) goto <D.39762>; else goto <D.39763>;
        <D.39762>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39764>; else goto <D.39765>;
        <D.39764>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 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.39759 = info->sig;
        D.39760 = D.39759->param_count;
        D.39771 = (long unsigned int) D.39760;
        D.39772 = D.39771 * 8;
        D.39773 = -D.39772;
        sp = sp + D.39773;
        D.39774 = info->func;
        ins = mono_emit_jit_icall (cfg, D.39774, sp);
        D.39759 = info->sig;
        D.39775 = D.39759->ret;
        D.39776 = mono_type_is_void (D.39775);
        if (D.39776 == 0) goto <D.39777>; else goto <D.39778>;
        <D.39777>:
        sp.279 = sp;
        sp = sp.279 + 8;
        *sp.279 = ins;
        <D.39778>:
        ip = ip + 6;
        num_calls.280 = num_calls;
        num_calls = num_calls.280 + 1;
        D.39781 = num_calls.280 * 10;
        inline_costs = D.39781 + inline_costs;
        goto <D.28614>;
      }
      <D.28615>:
      {
        void * ptr;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.39782>; else goto <D.39783>;
        <D.39782>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39784>; else goto <D.39785>;
        <D.39784>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39786>; else goto <D.39787>;
        <D.39786>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39787>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39785>:
        D.39788 = mini_get_debug_options ();
        D.39789 = D.39788->break_on_unverified;
        if (D.39789 != 0) goto <D.39790>; else goto unverified;
        <D.39790>:
        raise (5);
        <D.39783>:
        D.35709 = ip + 6;
        if (D.35709 > end) goto <D.39791>; else goto <D.39792>;
        <D.39791>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39793>; else goto <D.39794>;
        <D.39793>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39795>; else goto <D.39796>;
        <D.39795>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39796>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39794>:
        D.39797 = mini_get_debug_options ();
        D.39798 = D.39797->break_on_unverified;
        if (D.39798 != 0) goto <D.39799>; else goto unverified;
        <D.39799>:
        raise (5);
        <D.39792>:
        token = MEM[(const guint32 *)ip + 2B];
        ptr = mono_method_get_wrapper_data (method, token);
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39800>; else goto <D.39801>;
        <D.39800>:
        D.39802 = mono_thread_interruption_request_flag ();
        if (D.39802 == ptr) goto <D.39803>; else goto <D.39804>;
        <D.39803>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39806>; else goto <D.39807>;
        <D.39806>:
        iftmp.281 = 734;
        goto <D.39808>;
        <D.39807>:
        iftmp.281 = 363;
        <D.39808>:
        ins->opcode = iftmp.281;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39809>; else goto <D.39810>;
        <D.39809>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.30941 = cfg->mempool;
          group = mono_mempool_alloc (D.30941, 80);
          group->data.op[1].const_val = 0;
          D.39811 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.39811;
          group->prev = 0B;
          D.39812 = group->prev;
          group->next = D.39812;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.39813 = group->sreg3;
          group->sreg2 = D.39813;
          D.39814 = group->sreg2;
          group->sreg1 = D.39814;
          D.31162 = cfg->ip;
          group->cil_code = D.31162;
          group->data.op[0].src = 0B;
          group->data.op[1].src = 33B;
          D.39815 = got_loc->dreg;
          ins->sreg1 = D.39815;
          ins->data.op[1].p = group;
        }
        goto <D.39816>;
        <D.39810>:
        ins->data.op[0].p = 0B;
        ins->data.op[1].src = 33B;
        <D.39816>:
        ins->type = 3;
        D.39817 = alloc_dreg (cfg, 3);
        D.39818 = (int) D.39817;
        ins->dreg = D.39818;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39819>; else goto <D.39820>;
        <D.39819>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39821>;
        <D.39820>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39821>:
        sp.282 = sp;
        sp = sp.282 + 8;
        *sp.282 = ins;
        ip = ip + 6;
        goto <D.28614>;
        <D.39804>:
        <D.39801>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->data.op[0].p = ptr;
        ins->type = 3;
        D.39823 = alloc_dreg (cfg, 3);
        D.39824 = (int) D.39823;
        ins->dreg = D.39824;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39825>; else goto <D.39826>;
        <D.39825>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39827>;
        <D.39826>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39827>:
        sp.283 = sp;
        sp = sp.283 + 8;
        *sp.283 = ins;
        ip = ip + 6;
        num_calls.284 = num_calls;
        num_calls = num_calls.284 + 1;
        D.39830 = num_calls.284 * 10;
        inline_costs = D.39830 + inline_costs;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.39831>; else goto <D.39832>;
        <D.39831>:
        printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 11077);
        <D.39832>:
        cfg->disable_aot = 1;
        goto <D.28614>;
      }
      <D.28619>:
      {
        struct MonoJitICallInfo * callinfo;
        void * ptr;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.39833>; else goto <D.39834>;
        <D.39833>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39835>; else goto <D.39836>;
        <D.39835>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39837>; else goto <D.39838>;
        <D.39837>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39838>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39836>:
        D.39839 = mini_get_debug_options ();
        D.39840 = D.39839->break_on_unverified;
        if (D.39840 != 0) goto <D.39841>; else goto unverified;
        <D.39841>:
        raise (5);
        <D.39834>:
        D.35709 = ip + 6;
        if (D.35709 > end) goto <D.39842>; else goto <D.39843>;
        <D.39842>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39844>; else goto <D.39845>;
        <D.39844>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39846>; else goto <D.39847>;
        <D.39846>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39847>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39845>:
        D.39848 = mini_get_debug_options ();
        D.39849 = D.39848->break_on_unverified;
        if (D.39849 != 0) goto <D.39850>; else goto unverified;
        <D.39850>:
        raise (5);
        <D.39843>:
        token = MEM[(const guint32 *)ip + 2B];
        ptr = mono_method_get_wrapper_data (method, token);
        callinfo = mono_find_jit_icall_by_addr (ptr);
        D.39851 = callinfo == 0B;
        D.39852 = (long int) D.39851;
        D.39853 = __builtin_expect (D.39852, 0);
        if (D.39853 != 0) goto <D.39854>; else goto <D.39855>;
        <D.39854>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11090, "callinfo");
        <D.39855>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39857>; else goto <D.39858>;
        <D.39857>:
        iftmp.285 = 734;
        goto <D.39859>;
        <D.39858>:
        iftmp.285 = 363;
        <D.39859>:
        ins->opcode = iftmp.285;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39860>; else goto <D.39861>;
        <D.39860>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.30941 = cfg->mempool;
          group = mono_mempool_alloc (D.30941, 80);
          group->data.op[1].const_val = 0;
          D.39862 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.39862;
          group->prev = 0B;
          D.39863 = group->prev;
          group->next = D.39863;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.39864 = group->sreg3;
          group->sreg2 = D.39864;
          D.39865 = group->sreg2;
          group->sreg1 = D.39865;
          D.31162 = cfg->ip;
          group->cil_code = D.31162;
          D.39866 = callinfo->name;
          group->data.op[0].src = D.39866;
          group->data.op[1].src = 32B;
          D.39867 = got_loc->dreg;
          ins->sreg1 = D.39867;
          ins->data.op[1].p = group;
        }
        goto <D.39868>;
        <D.39861>:
        D.39866 = callinfo->name;
        ins->data.op[0].p = D.39866;
        ins->data.op[1].src = 32B;
        <D.39868>:
        ins->type = 3;
        D.39869 = alloc_dreg (cfg, 3);
        D.39870 = (int) D.39869;
        ins->dreg = D.39870;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39871>; else goto <D.39872>;
        <D.39871>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39873>;
        <D.39872>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39873>:
        sp.286 = sp;
        sp = sp.286 + 8;
        *sp.286 = ins;
        ip = ip + 6;
        num_calls.287 = num_calls;
        num_calls = num_calls.287 + 1;
        D.39876 = num_calls.287 * 10;
        inline_costs = D.39876 + inline_costs;
        goto <D.28614>;
      }
      <D.28624>:
      {
        struct MonoMethod * cmethod;
        void * ptr;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.39877>; else goto <D.39878>;
        <D.39877>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39879>; else goto <D.39880>;
        <D.39879>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 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>:
        D.35709 = ip + 6;
        if (D.35709 > end) goto <D.39886>; else goto <D.39887>;
        <D.39886>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39888>; else goto <D.39889>;
        <D.39888>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.39890>; else goto <D.39891>;
        <D.39890>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39891>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39889>:
        D.39892 = mini_get_debug_options ();
        D.39893 = D.39892->break_on_unverified;
        if (D.39893 != 0) goto <D.39894>; else goto unverified;
        <D.39894>:
        raise (5);
        <D.39887>:
        token = MEM[(const guint32 *)ip + 2B];
        cmethod = mono_method_get_wrapper_data (method, token);
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39895>; else goto <D.39896>;
        <D.39895>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39898>; else goto <D.39899>;
        <D.39898>:
        iftmp.288 = 734;
        goto <D.39900>;
        <D.39899>:
        iftmp.288 = 363;
        <D.39900>:
        ins->opcode = iftmp.288;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.39901>; else goto <D.39902>;
        <D.39901>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.30941 = cfg->mempool;
          group = mono_mempool_alloc (D.30941, 80);
          group->data.op[1].const_val = 0;
          D.39903 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.39903;
          group->prev = 0B;
          D.39904 = group->prev;
          group->next = D.39904;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.39905 = group->sreg3;
          group->sreg2 = D.39905;
          D.39906 = group->sreg2;
          group->sreg1 = D.39906;
          D.31162 = cfg->ip;
          group->cil_code = D.31162;
          group->data.op[0].src = cmethod;
          group->data.op[1].src = 31B;
          D.39907 = got_loc->dreg;
          ins->sreg1 = D.39907;
          ins->data.op[1].p = group;
        }
        goto <D.39908>;
        <D.39902>:
        ins->data.op[0].p = cmethod;
        ins->data.op[1].src = 31B;
        <D.39908>:
        ins->type = 3;
        D.39909 = alloc_dreg (cfg, 3);
        D.39910 = (int) D.39909;
        ins->dreg = D.39910;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39911>; else goto <D.39912>;
        <D.39911>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39913>;
        <D.39912>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39913>:
        goto <D.39914>;
        <D.39896>:
        ptr = mono_lookup_internal_call (cmethod);
        D.39915 = ptr == 0B;
        D.39916 = (long int) D.39915;
        D.39917 = __builtin_expect (D.39916, 0);
        if (D.39917 != 0) goto <D.39918>; else goto <D.39919>;
        <D.39918>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11111, "ptr");
        <D.39919>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->data.op[0].p = ptr;
        ins->type = 3;
        D.39920 = alloc_dreg (cfg, 3);
        D.39921 = (int) D.39920;
        ins->dreg = D.39921;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39922>; else goto <D.39923>;
        <D.39922>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.39924>;
        <D.39923>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39924>:
        <D.39914>:
        sp.289 = sp;
        sp = sp.289 + 8;
        *sp.289 = ins;
        ip = ip + 6;
        goto <D.28614>;
      }
      <D.28629>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.39926>; else goto <D.39927>;
        <D.39926>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.39928>; else goto <D.39929>;
        <D.39928>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 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>:
        sp = sp + 18446744073709551608;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37427 = (unsigned int) D.32139;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.37427 < D.32058) goto <D.39936>; else goto <D.39937>;
        <D.39936>:
        D.32061 = cfg->vreg_to_inst;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37430 = (long unsigned int) D.32139;
        D.37431 = D.37430 * 8;
        D.37432 = D.32061 + D.37431;
        iftmp.290 = *D.37432;
        goto <D.39938>;
        <D.39937>:
        iftmp.290 = 0B;
        <D.39938>:
        src_var = iftmp.290;
        D.30941 = cfg->mempool;
        src = mono_mempool_alloc (D.30941, 80);
        src->data.op[1].const_val = 0;
        D.39939 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.39939;
        src->prev = 0B;
        D.39940 = src->prev;
        src->next = D.39940;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.39941 = src->sreg3;
        src->sreg2 = D.39941;
        D.39942 = src->sreg2;
        src->sreg1 = D.39942;
        D.31162 = cfg->ip;
        src->cil_code = D.31162;
        src->data.op[0].p = src_var;
        D.39943 = src_var->flags;
        D.39944 = D.39943 | 16;
        src_var->flags = D.39944;
        src->type = 5;
        D.39945 = src_var->klass;
        src->klass = D.39945;
        D.39946 = alloc_dreg (cfg, 5);
        D.39947 = (int) D.39946;
        src->dreg = D.39947;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.39948>; else goto <D.39949>;
        <D.39948>:
        D.39950 = src_var->data.op[1].vtype;
        D.39951 = mini_is_gsharedvt_variable_type (cfg, D.39950);
        if (D.39951 != 0) goto <D.39952>; else goto <D.39953>;
        <D.39952>:
        handle_gsharedvt_ldaddr (cfg);
        <D.39953>:
        <D.39949>:
        if (0 != 0) goto <D.39954>; else goto <D.39955>;
        <D.39954>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.39957 = src_var->dreg;
          D.39958 = D.39957 + 1;
          D.39959 = (unsigned int) D.39958;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.39959 < D.32058) goto <D.39960>; else goto <D.39961>;
          <D.39960>:
          D.32061 = cfg->vreg_to_inst;
          D.39957 = src_var->dreg;
          D.39962 = (sizetype) D.39957;
          D.39963 = D.39962 + 1;
          D.39964 = D.39963 * 8;
          D.39965 = D.32061 + D.39964;
          iftmp.291 = *D.39965;
          goto <D.39966>;
          <D.39961>:
          iftmp.291 = 0B;
          <D.39966>:
          var1 = iftmp.291;
          D.39957 = src_var->dreg;
          D.39968 = D.39957 + 2;
          D.39969 = (unsigned int) D.39968;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.39969 < D.32058) goto <D.39970>; else goto <D.39971>;
          <D.39970>:
          D.32061 = cfg->vreg_to_inst;
          D.39957 = src_var->dreg;
          D.39962 = (sizetype) D.39957;
          D.39972 = D.39962 + 2;
          D.39973 = D.39972 * 8;
          D.39974 = D.32061 + D.39973;
          iftmp.292 = *D.39974;
          goto <D.39975>;
          <D.39971>:
          iftmp.292 = 0B;
          <D.39975>:
          var2 = iftmp.292;
          D.39976 = var1 == 0B;
          D.39977 = (long int) D.39976;
          D.39978 = __builtin_expect (D.39977, 0);
          if (D.39978 != 0) goto <D.39979>; else goto <D.39980>;
          <D.39979>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11126, "var1");
          <D.39980>:
          D.39981 = var2 == 0B;
          D.39982 = (long int) D.39981;
          D.39983 = __builtin_expect (D.39982, 0);
          if (D.39983 != 0) goto <D.39984>; else goto <D.39985>;
          <D.39984>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11126, "var2");
          <D.39985>:
          D.39986 = var1->flags;
          D.39987 = D.39986 | 16;
          var1->flags = D.39987;
          D.39988 = var2->flags;
          D.39989 = D.39988 | 16;
          var2->flags = D.39989;
        }
        <D.39955>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.39990>; else goto <D.39991>;
        <D.39990>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = src;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        src->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        goto <D.39992>;
        <D.39991>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.39992>:
        sp.293 = sp;
        sp = sp.293 + 8;
        *sp.293 = src;
        ip = ip + 2;
        goto <D.28614>;
      }
      <D.28634>:
      {
        struct MonoInst * iargs[2];

        try
          {
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.31641 = header->max_stack;
            D.31863 = (long int) D.31641;
            if (D.31731 >= D.31863) goto <D.39994>; else goto <D.39995>;
            <D.39994>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.39996>; else goto <D.39997>;
            <D.39996>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.39998>; else goto <D.39999>;
            <D.39998>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39999>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39997>:
            D.40000 = mini_get_debug_options ();
            D.40001 = D.40000->break_on_unverified;
            if (D.40001 != 0) goto <D.40002>; else goto unverified;
            <D.40002>:
            raise (5);
            <D.39995>:
            D.35709 = ip + 6;
            if (D.35709 > end) goto <D.40003>; else goto <D.40004>;
            <D.40003>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.40005>; else goto <D.40006>;
            <D.40005>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.40007>; else goto <D.40008>;
            <D.40007>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40008>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40006>:
            D.40009 = mini_get_debug_options ();
            D.40010 = D.40009->break_on_unverified;
            if (D.40010 != 0) goto <D.40011>; else goto unverified;
            <D.40011>:
            raise (5);
            <D.40004>:
            token = MEM[(const guint32 *)ip + 2B];
            klass.294 = mono_method_get_wrapper_data (method, token);
            klass = klass.294;
            klass.157 = klass;
            mono_class_init (klass.157);
            D.31334 = cfg->opt;
            D.31335 = D.31334 & 512;
            if (D.31335 != 0) goto <D.40013>; else goto <D.40016>;
            <D.40016>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.40013>; else goto <D.40014>;
            <D.40013>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.30941 = cfg->mempool;
              D.40017 = mono_mempool_alloc (D.30941, 80);
              iargs[0] = D.40017;
              D.40018 = iargs[0];
              D.40018 = iargs[0];
              D.40018->data.op[1].const_val = 0;
              D.40019 = D.40018->data.op[1].const_val;
              D.40018->data.op[0].const_val = D.40019;
              D.40018 = iargs[0];
              D.40018 = iargs[0];
              D.40018->prev = 0B;
              D.40020 = D.40018->prev;
              D.40018->next = D.40020;
              D.40018 = iargs[0];
              D.40018->opcode = 424;
              D.40018 = iargs[0];
              D.40018->flags = 0;
              D.40018 = iargs[0];
              D.40018->type = 0;
              D.40018 = iargs[0];
              D.40018->dreg = -1;
              D.40018 = iargs[0];
              D.40018 = iargs[0];
              D.40018 = iargs[0];
              D.40018->sreg3 = -1;
              D.40021 = D.40018->sreg3;
              D.40018->sreg2 = D.40021;
              D.40022 = D.40018->sreg2;
              D.40018->sreg1 = D.40022;
              D.40018 = iargs[0];
              D.31162 = cfg->ip;
              D.40018->cil_code = D.31162;
              D.40018 = iargs[0];
              D.31695 = cfg->varinfo;
              D.40023 = __domain_var->data.op[0].const_val;
              D.40024 = (long unsigned int) D.40023;
              D.40025 = D.40024 * 8;
              D.40026 = D.31695 + D.40025;
              D.40027 = *D.40026;
              D.40028 = D.40027->data.op[1].vtype;
              D.40029 = mono_type_to_regmove (cfg, D.40028);
              D.40030 = (short unsigned int) D.40029;
              D.40018->opcode = D.40030;
              D.31695 = cfg->varinfo;
              D.40023 = __domain_var->data.op[0].const_val;
              D.40024 = (long unsigned int) D.40023;
              D.40025 = D.40024 * 8;
              D.40026 = D.31695 + D.40025;
              D.40027 = *D.40026;
              D.40028 = D.40027->data.op[1].vtype;
              D.40018 = iargs[0];
              type_to_eval_stack_type (cfg, D.40028, D.40018);
              D.40018 = iargs[0];
              D.31695 = cfg->varinfo;
              D.40023 = __domain_var->data.op[0].const_val;
              D.40024 = (long unsigned int) D.40023;
              D.40025 = D.40024 * 8;
              D.40026 = D.31695 + D.40025;
              D.40027 = *D.40026;
              D.40031 = D.40027->klass;
              D.40018->klass = D.40031;
              D.40018 = iargs[0];
              D.31695 = cfg->varinfo;
              D.40023 = __domain_var->data.op[0].const_val;
              D.40024 = (long unsigned int) D.40023;
              D.40025 = D.40024 * 8;
              D.40026 = D.31695 + D.40025;
              D.40027 = *D.40026;
              D.40032 = D.40027->dreg;
              D.40018->sreg1 = D.40032;
              D.40018 = iargs[0];
              D.40018 = iargs[0];
              D.40033 = D.40018->type;
              D.40034 = (<unnamed type>) D.40033;
              D.40035 = alloc_dreg (cfg, D.40034);
              D.40036 = (int) D.40035;
              D.40018->dreg = D.40036;
              D.40018 = iargs[0];
              D.40037 = D.40018->opcode;
              if (D.40037 == 427) goto <D.40038>; else goto <D.40039>;
              <D.40038>:
              D.40018 = iargs[0];
              D.31695 = cfg->varinfo;
              D.40023 = __domain_var->data.op[0].const_val;
              D.40024 = (long unsigned int) D.40023;
              D.40025 = D.40024 * 8;
              D.40026 = D.31695 + D.40025;
              D.40027 = *D.40026;
              D.40028 = D.40027->data.op[1].vtype;
              D.40040 = mono_class_from_mono_type (D.40028);
              D.40018->klass = D.40040;
              <D.40039>:
            }
            goto <D.40015>;
            <D.40014>:
            D.30941 = cfg->mempool;
            D.40041 = mono_mempool_alloc (D.30941, 80);
            iargs[0] = D.40041;
            D.40018 = iargs[0];
            D.40018 = iargs[0];
            D.40018->data.op[1].const_val = 0;
            D.40019 = D.40018->data.op[1].const_val;
            D.40018->data.op[0].const_val = D.40019;
            D.40018 = iargs[0];
            D.40018 = iargs[0];
            D.40018->prev = 0B;
            D.40020 = D.40018->prev;
            D.40018->next = D.40020;
            D.40018 = iargs[0];
            D.40018->opcode = 363;
            D.40018 = iargs[0];
            D.40018->flags = 0;
            D.40018 = iargs[0];
            D.40018->type = 0;
            D.40018 = iargs[0];
            D.40018->dreg = -1;
            D.40018 = iargs[0];
            D.40018 = iargs[0];
            D.40018 = iargs[0];
            D.40018->sreg3 = -1;
            D.40021 = D.40018->sreg3;
            D.40018->sreg2 = D.40021;
            D.40022 = D.40018->sreg2;
            D.40018->sreg1 = D.40022;
            D.40018 = iargs[0];
            D.31162 = cfg->ip;
            D.40018->cil_code = D.31162;
            D.40018 = iargs[0];
            D.30966 = cfg->domain;
            D.40018->data.op[0].p = D.30966;
            D.40018 = iargs[0];
            D.40018->type = 3;
            D.40018 = iargs[0];
            D.40042 = alloc_dreg (cfg, 3);
            D.40043 = (int) D.40042;
            D.40018->dreg = D.40043;
            <D.40015>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40044>; else goto <D.40045>;
            <D.40044>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40018 = iargs[0];
            D.31191->next = D.40018;
            D.40018 = iargs[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40018->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.40018 = iargs[0];
            bblock.113->last_ins = D.40018;
            goto <D.40046>;
            <D.40045>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.40018 = iargs[0];
            bblock.113->last_ins = D.40018;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40046>:
            D.30941 = cfg->mempool;
            D.40047 = mono_mempool_alloc (D.30941, 80);
            iargs[1] = D.40047;
            D.40048 = iargs[1];
            D.40048 = iargs[1];
            D.40048->data.op[1].const_val = 0;
            D.40049 = D.40048->data.op[1].const_val;
            D.40048->data.op[0].const_val = D.40049;
            D.40048 = iargs[1];
            D.40048 = iargs[1];
            D.40048->prev = 0B;
            D.40050 = D.40048->prev;
            D.40048->next = D.40050;
            D.40048 = iargs[1];
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.40052>; else goto <D.40053>;
            <D.40052>:
            iftmp.295 = 734;
            goto <D.40054>;
            <D.40053>:
            iftmp.295 = 363;
            <D.40054>:
            D.40048->opcode = iftmp.295;
            D.40048 = iargs[1];
            D.40048->flags = 0;
            D.40048 = iargs[1];
            D.40048->type = 0;
            D.40048 = iargs[1];
            D.40048->dreg = -1;
            D.40048 = iargs[1];
            D.40048 = iargs[1];
            D.40048 = iargs[1];
            D.40048->sreg3 = -1;
            D.40055 = D.40048->sreg3;
            D.40048->sreg2 = D.40055;
            D.40056 = D.40048->sreg2;
            D.40048->sreg1 = D.40056;
            D.40048 = iargs[1];
            D.31162 = cfg->ip;
            D.40048->cil_code = D.31162;
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.40057>; else goto <D.40058>;
            <D.40057>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.30941 = cfg->mempool;
              group = mono_mempool_alloc (D.30941, 80);
              group->data.op[1].const_val = 0;
              D.40059 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.40059;
              group->prev = 0B;
              D.40060 = group->prev;
              group->next = D.40060;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.40061 = group->sreg3;
              group->sreg2 = D.40061;
              D.40062 = group->sreg2;
              group->sreg1 = D.40062;
              D.31162 = cfg->ip;
              group->cil_code = D.31162;
              klass.157 = klass;
              group->data.op[0].src = klass.157;
              group->data.op[1].src = 11B;
              D.40048 = iargs[1];
              D.40063 = got_loc->dreg;
              D.40048->sreg1 = D.40063;
              D.40048 = iargs[1];
              D.40048->data.op[1].p = group;
            }
            goto <D.40064>;
            <D.40058>:
            D.40048 = iargs[1];
            klass.157 = klass;
            D.40048->data.op[0].p = klass.157;
            D.40048 = iargs[1];
            D.40048->data.op[1].src = 11B;
            <D.40064>:
            D.40048 = iargs[1];
            D.40048->type = 3;
            D.40048 = iargs[1];
            D.40065 = alloc_dreg (cfg, 3);
            D.40066 = (int) D.40065;
            D.40048->dreg = D.40066;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40067>; else goto <D.40068>;
            <D.40067>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40048 = iargs[1];
            D.31191->next = D.40048;
            D.40048 = iargs[1];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40048->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.40048 = iargs[1];
            bblock.113->last_ins = D.40048;
            goto <D.40069>;
            <D.40068>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.40048 = iargs[1];
            bblock.113->last_ins = D.40048;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40069>:
            sp.296 = sp;
            sp = sp.296 + 8;
            D.40071 = mono_emit_jit_icall (cfg, mono_object_new, &iargs);
            *sp.296 = D.40071;
            ip = ip + 6;
            num_calls.297 = num_calls;
            num_calls = num_calls.297 + 1;
            D.40073 = num_calls.297 * 10;
            inline_costs = D.40073 + inline_costs;
            goto <D.28614>;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.28639>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.40074>; else goto <D.40075>;
      <D.40074>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40076>; else goto <D.40077>;
      <D.40076>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40078>; else goto <D.40079>;
      <D.40078>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40079>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40077>:
      D.40080 = mini_get_debug_options ();
      D.40081 = D.40080->break_on_unverified;
      if (D.40081 != 0) goto <D.40082>; else goto unverified;
      <D.40082>:
      raise (5);
      <D.40075>:
      sp = sp + 18446744073709551608;
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.40083 = alloc_ireg_mp (cfg);
      D.40084 = (int) D.40083;
      ins->dreg = D.40084;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ins->type = 5;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.40085>; else goto <D.40086>;
      <D.40085>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.40087>;
      <D.40086>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.40087>:
      sp.298 = sp;
      sp = sp.298 + 8;
      *sp.298 = ins;
      ip = ip + 2;
      goto <D.28614>;
      <D.28640>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.40089>; else goto <D.40090>;
      <D.40089>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40091>; else goto <D.40092>;
      <D.40091>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40093>; else goto <D.40094>;
      <D.40093>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40094>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40092>:
      D.40095 = mini_get_debug_options ();
      D.40096 = D.40095->break_on_unverified;
      if (D.40096 != 0) goto <D.40097>; else goto unverified;
      <D.40097>:
      raise (5);
      <D.40090>:
      D.35709 = ip + 6;
      if (D.35709 > end) goto <D.40098>; else goto <D.40099>;
      <D.40098>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40100>; else goto <D.40101>;
      <D.40100>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40102>; else goto <D.40103>;
      <D.40102>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40103>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40101>:
      D.40104 = mini_get_debug_options ();
      D.40105 = D.40104->break_on_unverified;
      if (D.40105 != 0) goto <D.40106>; else goto unverified;
      <D.40106>:
      raise (5);
      <D.40099>:
      sp = sp + 18446744073709551608;
      token = MEM[(const guint32 *)ip + 2B];
      klass.299 = mono_method_get_wrapper_data (method, token);
      klass = klass.299;
      klass.157 = klass;
      D.36474 = BIT_FIELD_REF <*klass.157, 64, 256>;
      D.37152 = D.36474 & 8;
      D.40108 = D.37152 == 0;
      D.40109 = (long int) D.40108;
      D.40110 = __builtin_expect (D.40109, 0);
      if (D.40110 != 0) goto <D.40111>; else goto <D.40112>;
      <D.40111>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11169, "klass->valuetype");
      <D.40112>:
      klass.157 = klass;
      mono_class_init (klass.157);
      {
        struct MonoInst * src;
        struct MonoInst * dest;
        struct MonoInst * temp;

        src = *sp;
        klass.157 = klass;
        D.35726 = &klass.157->byval_arg;
        temp = mono_compile_create_var (cfg, D.35726, 329);
        temp->backend.is_pinvoke = 1;
        D.30941 = cfg->mempool;
        dest = mono_mempool_alloc (D.30941, 80);
        dest->data.op[1].const_val = 0;
        D.40113 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.40113;
        dest->prev = 0B;
        D.40114 = dest->prev;
        dest->next = D.40114;
        dest->opcode = 314;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.40115 = dest->sreg3;
        dest->sreg2 = D.40115;
        D.40116 = dest->sreg2;
        dest->sreg1 = D.40116;
        D.31162 = cfg->ip;
        dest->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        dest->data.op[0].p = D.40121;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40122 = D.40121->flags;
        D.40123 = D.40122 | 16;
        D.40121->flags = D.40123;
        dest->type = 5;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40124 = D.40121->klass;
        dest->klass = D.40124;
        D.40125 = alloc_dreg (cfg, 5);
        D.40126 = (int) D.40125;
        dest->dreg = D.40126;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.40127>; else goto <D.40128>;
        <D.40127>:
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40129 = D.40121->data.op[1].vtype;
        D.40130 = mini_is_gsharedvt_variable_type (cfg, D.40129);
        if (D.40130 != 0) goto <D.40131>; else goto <D.40132>;
        <D.40131>:
        handle_gsharedvt_ldaddr (cfg);
        <D.40132>:
        <D.40128>:
        if (0 != 0) goto <D.40133>; else goto <D.40134>;
        <D.40133>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31695 = cfg->varinfo;
          D.40117 = temp->data.op[0].const_val;
          D.40118 = (long unsigned int) D.40117;
          D.40119 = D.40118 * 8;
          D.40120 = D.31695 + D.40119;
          D.40121 = *D.40120;
          D.40136 = D.40121->dreg;
          D.40137 = D.40136 + 1;
          D.40138 = (unsigned int) D.40137;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.40138 < D.32058) goto <D.40139>; else goto <D.40140>;
          <D.40139>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.40117 = temp->data.op[0].const_val;
          D.40118 = (long unsigned int) D.40117;
          D.40119 = D.40118 * 8;
          D.40120 = D.31695 + D.40119;
          D.40121 = *D.40120;
          D.40136 = D.40121->dreg;
          D.40141 = (sizetype) D.40136;
          D.40142 = D.40141 + 1;
          D.40143 = D.40142 * 8;
          D.40144 = D.32061 + D.40143;
          iftmp.300 = *D.40144;
          goto <D.40145>;
          <D.40140>:
          iftmp.300 = 0B;
          <D.40145>:
          var1 = iftmp.300;
          D.31695 = cfg->varinfo;
          D.40117 = temp->data.op[0].const_val;
          D.40118 = (long unsigned int) D.40117;
          D.40119 = D.40118 * 8;
          D.40120 = D.31695 + D.40119;
          D.40121 = *D.40120;
          D.40136 = D.40121->dreg;
          D.40147 = D.40136 + 2;
          D.40148 = (unsigned int) D.40147;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.40148 < D.32058) goto <D.40149>; else goto <D.40150>;
          <D.40149>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.40117 = temp->data.op[0].const_val;
          D.40118 = (long unsigned int) D.40117;
          D.40119 = D.40118 * 8;
          D.40120 = D.31695 + D.40119;
          D.40121 = *D.40120;
          D.40136 = D.40121->dreg;
          D.40141 = (sizetype) D.40136;
          D.40151 = D.40141 + 2;
          D.40152 = D.40151 * 8;
          D.40153 = D.32061 + D.40152;
          iftmp.301 = *D.40153;
          goto <D.40154>;
          <D.40150>:
          iftmp.301 = 0B;
          <D.40154>:
          var2 = iftmp.301;
          D.40155 = var1 == 0B;
          D.40156 = (long int) D.40155;
          D.40157 = __builtin_expect (D.40156, 0);
          if (D.40157 != 0) goto <D.40158>; else goto <D.40159>;
          <D.40158>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11178, "var1");
          <D.40159>:
          D.40160 = var2 == 0B;
          D.40161 = (long int) D.40160;
          D.40162 = __builtin_expect (D.40161, 0);
          if (D.40162 != 0) goto <D.40163>; else goto <D.40164>;
          <D.40163>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11178, "var2");
          <D.40164>:
          D.40165 = var1->flags;
          D.40166 = D.40165 | 16;
          var1->flags = D.40166;
          D.40167 = var2->flags;
          D.40168 = D.40167 | 16;
          var2->flags = D.40168;
        }
        <D.40134>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.40169>; else goto <D.40170>;
        <D.40169>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = dest;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        dest->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = dest;
        goto <D.40171>;
        <D.40170>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = dest;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.40171>:
        klass.157 = klass;
        mini_emit_stobj (cfg, dest, src, klass.157, 1);
        D.30941 = cfg->mempool;
        dest = mono_mempool_alloc (D.30941, 80);
        dest->data.op[1].const_val = 0;
        D.40113 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.40113;
        dest->prev = 0B;
        D.40114 = dest->prev;
        dest->next = D.40114;
        dest->opcode = 424;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.40115 = dest->sreg3;
        dest->sreg2 = D.40115;
        D.40116 = dest->sreg2;
        dest->sreg1 = D.40116;
        D.31162 = cfg->ip;
        dest->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40129 = D.40121->data.op[1].vtype;
        D.40172 = mono_type_to_regmove (cfg, D.40129);
        D.40173 = (short unsigned int) D.40172;
        dest->opcode = D.40173;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40129 = D.40121->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.40129, dest);
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40124 = D.40121->klass;
        dest->klass = D.40124;
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40136 = D.40121->dreg;
        dest->sreg1 = D.40136;
        D.40174 = dest->type;
        D.40175 = (<unnamed type>) D.40174;
        D.40176 = alloc_dreg (cfg, D.40175);
        D.40177 = (int) D.40176;
        dest->dreg = D.40177;
        D.40178 = dest->opcode;
        if (D.40178 == 427) goto <D.40179>; else goto <D.40180>;
        <D.40179>:
        D.31695 = cfg->varinfo;
        D.40117 = temp->data.op[0].const_val;
        D.40118 = (long unsigned int) D.40117;
        D.40119 = D.40118 * 8;
        D.40120 = D.31695 + D.40119;
        D.40121 = *D.40120;
        D.40129 = D.40121->data.op[1].vtype;
        D.40181 = mono_class_from_mono_type (D.40129);
        dest->klass = D.40181;
        <D.40180>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.40182>; else goto <D.40183>;
        <D.40182>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = dest;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        dest->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = dest;
        goto <D.40184>;
        <D.40183>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = dest;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.40184>:
        dest->type = 7;
        klass.157 = klass;
        dest->klass = klass.157;
        sp.302 = sp;
        sp = sp.302 + 8;
        *sp.302 = dest;
        ip = ip + 6;
      }
      goto <D.28614>;
      <D.28646>:
      D.34464 = cfg->ret;
      D.40186 = D.34464 == 0B;
      D.40187 = (long int) D.40186;
      D.40188 = __builtin_expect (D.40187, 0);
      if (D.40188 != 0) goto <D.40189>; else goto <D.40190>;
      <D.40189>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11194, "cfg->ret");
      <D.40190>:
      D.40191 = mono_method_signature (method);
      D.40192 = BIT_FIELD_REF <*D.40191, 64, 64>;
      D.40193 = D.40192 & 72057594037927936;
      D.40194 = D.40193 == 0;
      D.40195 = (long int) D.40194;
      D.40196 = __builtin_expect (D.40195, 0);
      if (D.40196 != 0) goto <D.40197>; else goto <D.40198>;
      <D.40197>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11195, "mono_method_signature (method)->pinvoke");
      <D.40198>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.40199>; else goto <D.40200>;
      <D.40199>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40201>; else goto <D.40202>;
      <D.40201>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40203>; else goto <D.40204>;
      <D.40203>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40204>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40202>:
      D.40205 = mini_get_debug_options ();
      D.40206 = D.40205->break_on_unverified;
      if (D.40206 != 0) goto <D.40207>; else goto unverified;
      <D.40207>:
      raise (5);
      <D.40200>:
      sp = sp + 18446744073709551608;
      D.35709 = ip + 6;
      if (D.35709 > end) goto <D.40208>; else goto <D.40209>;
      <D.40208>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40210>; else goto <D.40211>;
      <D.40210>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40212>; else goto <D.40213>;
      <D.40212>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40213>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40211>:
      D.40214 = mini_get_debug_options ();
      D.40215 = D.40214->break_on_unverified;
      if (D.40215 != 0) goto <D.40216>; else goto unverified;
      <D.40216>:
      raise (5);
      <D.40209>:
      token = MEM[(const guint32 *)ip + 2B];
      klass.303 = mono_method_get_wrapper_data (method, token);
      klass = klass.303;
      D.34506 = cfg->vret_addr;
      if (D.34506 == 0B) goto <D.40218>; else goto <D.40219>;
      <D.40218>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.40220 = D.31336 & 4398046511104;
      D.40221 = D.40220 == 0;
      D.40222 = (long int) D.40221;
      D.40223 = __builtin_expect (D.40222, 0);
      if (D.40223 != 0) goto <D.40224>; else goto <D.40225>;
      <D.40224>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11204, "cfg->ret_var_is_local");
      <D.40225>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.34464 = cfg->ret;
      ins->data.op[0].p = D.34464;
      D.34464 = cfg->ret;
      D.34464 = cfg->ret;
      D.40226 = D.34464->flags;
      D.40227 = D.40226 | 16;
      D.34464->flags = D.40227;
      ins->type = 5;
      D.34464 = cfg->ret;
      D.34515 = D.34464->klass;
      ins->klass = D.34515;
      D.40228 = alloc_dreg (cfg, 5);
      D.40229 = (int) D.40228;
      ins->dreg = D.40229;
      cfg->has_indirection = 1;
      D.31089 = cfg->gsharedvt;
      D.32043 = D.31089 != 0;
      D.32044 = (long int) D.32043;
      D.32045 = __builtin_expect (D.32044, 0);
      if (D.32045 != 0) goto <D.40230>; else goto <D.40231>;
      <D.40230>:
      D.34464 = cfg->ret;
      D.40232 = D.34464->data.op[1].vtype;
      D.40233 = mini_is_gsharedvt_variable_type (cfg, D.40232);
      if (D.40233 != 0) goto <D.40234>; else goto <D.40235>;
      <D.40234>:
      handle_gsharedvt_ldaddr (cfg);
      <D.40235>:
      <D.40231>:
      if (0 != 0) goto <D.40236>; else goto <D.40237>;
      <D.40236>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.34464 = cfg->ret;
        D.34516 = D.34464->dreg;
        D.40239 = D.34516 + 1;
        D.40240 = (unsigned int) D.40239;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.40240 < D.32058) goto <D.40241>; else goto <D.40242>;
        <D.40241>:
        D.32061 = cfg->vreg_to_inst;
        D.34464 = cfg->ret;
        D.34516 = D.34464->dreg;
        D.40243 = (sizetype) D.34516;
        D.40244 = D.40243 + 1;
        D.40245 = D.40244 * 8;
        D.40246 = D.32061 + D.40245;
        iftmp.304 = *D.40246;
        goto <D.40247>;
        <D.40242>:
        iftmp.304 = 0B;
        <D.40247>:
        var1 = iftmp.304;
        D.34464 = cfg->ret;
        D.34516 = D.34464->dreg;
        D.40249 = D.34516 + 2;
        D.40250 = (unsigned int) D.40249;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.40250 < D.32058) goto <D.40251>; else goto <D.40252>;
        <D.40251>:
        D.32061 = cfg->vreg_to_inst;
        D.34464 = cfg->ret;
        D.34516 = D.34464->dreg;
        D.40243 = (sizetype) D.34516;
        D.40253 = D.40243 + 2;
        D.40254 = D.40253 * 8;
        D.40255 = D.32061 + D.40254;
        iftmp.305 = *D.40255;
        goto <D.40256>;
        <D.40252>:
        iftmp.305 = 0B;
        <D.40256>:
        var2 = iftmp.305;
        D.40257 = var1 == 0B;
        D.40258 = (long int) D.40257;
        D.40259 = __builtin_expect (D.40258, 0);
        if (D.40259 != 0) goto <D.40260>; else goto <D.40261>;
        <D.40260>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11206, "var1");
        <D.40261>:
        D.40262 = var2 == 0B;
        D.40263 = (long int) D.40262;
        D.40264 = __builtin_expect (D.40263, 0);
        if (D.40264 != 0) goto <D.40265>; else goto <D.40266>;
        <D.40265>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11206, "var2");
        <D.40266>:
        D.40267 = var1->flags;
        D.40268 = D.40267 | 16;
        var1->flags = D.40268;
        D.40269 = var2->flags;
        D.40270 = D.40269 | 16;
        var2->flags = D.40270;
      }
      <D.40237>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.40271>; else goto <D.40272>;
      <D.40271>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.40273>;
      <D.40272>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.40273>:
      goto <D.40274>;
      <D.40219>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->type = 5;
      D.34464 = cfg->ret;
      D.34515 = D.34464->klass;
      ins->klass = D.34515;
      D.34506 = cfg->vret_addr;
      D.34529 = D.34506->dreg;
      ins->sreg1 = D.34529;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.40275 = alloc_dreg (cfg, D.31706);
      D.40276 = (int) D.40275;
      ins->dreg = D.40276;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.40277>; else goto <D.40278>;
      <D.40277>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.40279>;
      <D.40278>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.40279>:
      <D.40274>:
      D.31957 = *sp;
      klass.157 = klass;
      mini_emit_stobj (cfg, ins, D.31957, klass.157, 1);
      if (sp != stack_start) goto <D.40280>; else goto <D.40281>;
      <D.40280>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40282>; else goto <D.40283>;
      <D.40282>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40284>; else goto <D.40285>;
      <D.40284>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40285>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40283>:
      D.40286 = mini_get_debug_options ();
      D.40287 = D.40286->break_on_unverified;
      if (D.40287 != 0) goto <D.40288>; else goto unverified;
      <D.40288>:
      raise (5);
      <D.40281>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[0].target_block = end_bblock;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      if (D.31279 != 0B) goto <D.40289>; else goto <D.40290>;
      <D.40289>:
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      D.31279->next = ins;
      bblock.70 = bblock;
      D.31279 = bblock.70->last_ins;
      ins->prev = D.31279;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      goto <D.40291>;
      <D.40290>:
      bblock.70 = bblock;
      bblock.70 = bblock;
      bblock.70->last_ins = ins;
      D.31279 = bblock.70->last_ins;
      bblock.70->code = D.31279;
      <D.40291>:
      bblock.70 = bblock;
      link_bblock (cfg, bblock.70, end_bblock);
      start_new_bblock = 1;
      ip = ip + 6;
      goto <D.28614>;
      <D.28649>:
      <D.28650>:
      {
        int token;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.40292>; else goto <D.40293>;
        <D.40292>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40294>; else goto <D.40295>;
        <D.40294>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40296>; else goto <D.40297>;
        <D.40296>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40297>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40295>:
        D.40298 = mini_get_debug_options ();
        D.40299 = D.40298->break_on_unverified;
        if (D.40299 != 0) goto <D.40300>; else goto unverified;
        <D.40300>:
        raise (5);
        <D.40293>:
        sp = sp + 18446744073709551608;
        D.35709 = ip + 6;
        if (D.35709 > end) goto <D.40301>; else goto <D.40302>;
        <D.40301>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40303>; else goto <D.40304>;
        <D.40303>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40305>; else goto <D.40306>;
        <D.40305>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40306>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40304>:
        D.40307 = mini_get_debug_options ();
        D.40308 = D.40307->break_on_unverified;
        if (D.40308 != 0) goto <D.40309>; else goto unverified;
        <D.40309>:
        raise (5);
        <D.40302>:
        D.40310 = ip + 2;
        D.40311 = *D.40310;
        token = (int) D.40311;
        token.306 = (unsigned int) token;
        klass.307 = mono_method_get_wrapper_data (method, token.306);
        klass = klass.307;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        if (D.31988 == 7) goto <D.40314>; else goto <D.40315>;
        <D.40314>:
        klass.157 = klass;
        D.31957 = *sp;
        ins = handle_cisinst (cfg, klass.157, D.31957);
        goto <D.40316>;
        <D.40315>:
        klass.157 = klass;
        D.31957 = *sp;
        ins = handle_ccastclass (cfg, klass.157, D.31957);
        <D.40316>:
        bblock.113 = cfg->cbb;
        bblock = bblock.113;
        sp.308 = sp;
        sp = sp.308 + 8;
        *sp.308 = ins;
        ip = ip + 6;
        goto <D.28614>;
      }
      <D.28652>:
      <D.28653>:
      ip = ip + 2;
      goto <D.28614>;
      <D.28654>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.40318>; else goto <D.40319>;
      <D.40318>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40320>; else goto <D.40321>;
      <D.40320>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40322>; else goto <D.40323>;
      <D.40322>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40323>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40321>:
      D.40324 = mini_get_debug_options ();
      D.40325 = D.40324->break_on_unverified;
      if (D.40325 != 0) goto <D.40326>; else goto unverified;
      <D.40326>:
      raise (5);
      <D.40319>:
      D.35709 = ip + 6;
      if (D.35709 > end) goto <D.40327>; else goto <D.40328>;
      <D.40327>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40329>; else goto <D.40330>;
      <D.40329>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40331>; else goto <D.40332>;
      <D.40331>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40332>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40330>:
      D.40333 = mini_get_debug_options ();
      D.40334 = D.40333->break_on_unverified;
      if (D.40334 != 0) goto <D.40335>; else goto unverified;
      <D.40335>:
      raise (5);
      <D.40328>:
      token = MEM[(const guint32 *)ip + 2B];
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31337 = D.31336 & 274877906944;
      if (D.31337 != 0) goto <D.40337>; else goto <D.40338>;
      <D.40337>:
      iftmp.309 = 734;
      goto <D.40339>;
      <D.40338>:
      iftmp.309 = 363;
      <D.40339>:
      ins->opcode = iftmp.309;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31337 = D.31336 & 274877906944;
      if (D.31337 != 0) goto <D.40340>; else goto <D.40341>;
      <D.40340>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.30941 = cfg->mempool;
        group = mono_mempool_alloc (D.30941, 80);
        group->data.op[1].const_val = 0;
        D.40342 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.40342;
        group->prev = 0B;
        D.40343 = group->prev;
        group->next = D.40343;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.40344 = group->sreg3;
        group->sreg2 = D.40344;
        D.40345 = group->sreg2;
        group->sreg1 = D.40345;
        D.31162 = cfg->ip;
        group->cil_code = D.31162;
        D.40346 = mono_method_get_wrapper_data (method, token);
        group->data.op[0].src = D.40346;
        group->data.op[1].src = 11B;
        D.40347 = got_loc->dreg;
        ins->sreg1 = D.40347;
        ins->data.op[1].p = group;
      }
      goto <D.40348>;
      <D.40341>:
      D.40349 = mono_method_get_wrapper_data (method, token);
      ins->data.op[0].p = D.40349;
      ins->data.op[1].src = 11B;
      <D.40348>:
      ins->type = 3;
      D.40350 = alloc_dreg (cfg, 3);
      D.40351 = (int) D.40350;
      ins->dreg = D.40351;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.40352>; else goto <D.40353>;
      <D.40352>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.40354>;
      <D.40353>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.40354>:
      sp.310 = sp;
      sp = sp.310 + 8;
      *sp.310 = ins;
      ip = ip + 6;
      num_calls.311 = num_calls;
      num_calls = num_calls.311 + 1;
      D.40357 = num_calls.311 * 10;
      inline_costs = D.40357 + inline_costs;
      goto <D.28614>;
      <D.28657>:
      bblock.70 = bblock;
      bblock.70->out_of_line = 1;
      ip = ip + 2;
      goto <D.28614>;
      <D.28658>:
      {
        int key;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.40358>; else goto <D.40359>;
        <D.40358>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40360>; else goto <D.40361>;
        <D.40360>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40362>; else goto <D.40363>;
        <D.40362>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40363>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40361>:
        D.40364 = mini_get_debug_options ();
        D.40365 = D.40364->break_on_unverified;
        if (D.40365 != 0) goto <D.40366>; else goto unverified;
        <D.40366>:
        raise (5);
        <D.40359>:
        D.35709 = ip + 6;
        if (D.35709 > end) goto <D.40367>; else goto <D.40368>;
        <D.40367>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40369>; else goto <D.40370>;
        <D.40369>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40371>; else goto <D.40372>;
        <D.40371>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40372>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40370>:
        D.40373 = mini_get_debug_options ();
        D.40374 = D.40373->break_on_unverified;
        if (D.40374 != 0) goto <D.40375>; else goto unverified;
        <D.40375>:
        raise (5);
        <D.40368>:
        D.40310 = ip + 2;
        D.40311 = *D.40310;
        key = (int) D.40311;
        D.40376 = key > 8;
        D.40377 = (long int) D.40376;
        D.40378 = __builtin_expect (D.40377, 0);
        if (D.40378 != 0) goto <D.40379>; else goto <D.40380>;
        <D.40379>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11268, "key < TLS_KEY_NUM");
        <D.40380>:
        key.312 = (<unnamed type>) key;
        ins = mono_create_tls_get (cfg, key.312);
        if (ins == 0B) goto <D.40382>; else goto <D.40383>;
        <D.40382>:
        D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31337 = D.31336 & 274877906944;
        if (D.31337 != 0) goto <D.40384>; else goto <D.40385>;
        <D.40384>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.40386>; else goto <D.40387>;
        <D.40386>:
        printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 11273);
        <D.40387>:
        cfg->disable_aot = 1;
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 791;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.40388 = alloc_preg (cfg);
        D.40389 = (int) D.40388;
        ins->dreg = D.40389;
        ins->type = 3;
        goto <D.40390>;
        <D.40385>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11278);
        <D.40390>:
        <D.40383>:
        ins->type = 3;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.40391>; else goto <D.40392>;
        <D.40391>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.40393>;
        <D.40392>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.40393>:
        sp.313 = sp;
        sp = sp.313 + 8;
        *sp.313 = ins;
        ip = ip + 6;
        goto <D.28614>;
      }
      <D.28660>:
      {
        struct MonoCallInst * call;

        D.40395 = cfg->dyn_call_var;
        if (D.40395 == 0B) goto <D.40396>; else goto <D.40397>;
        <D.40396>:
        D.31348 = mono_defaults.int_class;
        D.31349 = &D.31348->byval_arg;
        D.40398 = mono_compile_create_var (cfg, D.31349, 329);
        cfg->dyn_call_var = D.40398;
        D.40395 = cfg->dyn_call_var;
        D.40395 = cfg->dyn_call_var;
        D.40399 = D.40395->flags;
        D.40400 = D.40399 | 4;
        D.40395->flags = D.40400;
        <D.40397>:
        D.30941 = cfg->mempool;
        call = mono_mempool_alloc0 (D.30941, 192);
        call->inst.opcode = 361;
        call->inst.dreg = -1;
        call->inst.sreg3 = -1;
        D.40401 = call->inst.sreg3;
        call->inst.sreg2 = D.40401;
        D.40402 = call->inst.sreg2;
        call->inst.sreg1 = D.40402;
        D.31162 = cfg->ip;
        call->inst.cil_code = D.31162;
        ins = call;
        sp = sp + 18446744073709551600;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        ins->sreg1 = D.32139;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        ins->sreg2 = D.33091;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.40403>; else goto <D.40404>;
        <D.40403>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.40405>;
        <D.40404>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.40405>:
        D.40406 = cfg->param_area;
        cfg->param_area = D.40406;
        ip = ip + 2;
        num_calls.314 = num_calls;
        num_calls = num_calls.314 + 1;
        D.40408 = num_calls.314 * 10;
        inline_costs = D.40408 + inline_costs;
        goto <D.28614>;
      }
      <D.28662>:
      D.32381 = ip + 5;
      if (D.32381 > end) goto <D.40409>; else goto <D.40410>;
      <D.40409>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40411>; else goto <D.40412>;
      <D.40411>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40413>; else goto <D.40414>;
      <D.40413>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40414>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40412>:
      D.40415 = mini_get_debug_options ();
      D.40416 = D.40415->break_on_unverified;
      if (D.40416 != 0) goto <D.40417>; else goto unverified;
      <D.40417>:
      raise (5);
      <D.40410>:
      D.32400 = ip + 1;
      D.32401 = *D.32400;
      D.32402 = (int) D.32401;
      emit_memory_barrier (cfg, D.32402);
      ip = ip + 5;
      goto <D.28614>;
      <D.28663>:
      {
        struct MonoInst * args[16];
        struct MonoInst * ad_ins;
        struct MonoInst * lmf_ins;
        struct MonoBasicBlock * next_bb;

        try
          {
            next_bb = 0B;
            D.31348 = mono_defaults.int_class;
            D.31349 = &D.31348->byval_arg;
            D.40418 = mono_compile_create_var (cfg, D.31349, 329);
            cfg->orig_domain_var = D.40418;
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 363;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            ins->data.op[0].p = 0B;
            ins->type = 3;
            D.40419 = alloc_dreg (cfg, 3);
            D.40420 = (int) D.40419;
            ins->dreg = D.40420;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40421>; else goto <D.40422>;
            <D.40421>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.40423>;
            <D.40422>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40423>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.40424 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.40424;
              inst->prev = 0B;
              D.40425 = inst->prev;
              inst->next = D.40425;
              inst->opcode = 424;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.40426 = inst->sreg3;
              inst->sreg2 = D.40426;
              D.40427 = inst->sreg2;
              inst->sreg1 = D.40427;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              D.40428 = cfg->orig_domain_var;
              D.40429 = D.40428->dreg;
              inst->dreg = D.40429;
              D.31356 = ins->dreg;
              inst->sreg1 = D.31356;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40430>; else goto <D.40431>;
              <D.40430>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.40432>;
              <D.40431>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40432>:
            }
            ad_ins = mono_get_domain_intrinsic (cfg);
            lmf_ins = mono_get_lmf_intrinsic (cfg);
            if (ad_ins != 0B) goto <D.40433>; else goto <D.40434>;
            <D.40433>:
            if (lmf_ins != 0B) goto <D.40435>; else goto <D.40436>;
            <D.40435>:
            D.30941 = cfg->mempool;
            next_bb = mono_mempool_alloc0 (D.30941, 296);
            D.31048 = cfg->num_bblocks;
            D.40437 = D.31048;
            D.40438 = D.40437 + 1;
            cfg->num_bblocks = D.40438;
            D.40439 = (int) D.40437;
            next_bb->block_num = D.40439;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40440>; else goto <D.40441>;
            <D.40440>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ad_ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ad_ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ad_ins;
            goto <D.40442>;
            <D.40441>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ad_ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40442>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.40443 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.40443;
              inst->prev = 0B;
              D.40444 = inst->prev;
              inst->next = D.40444;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.40445 = inst->sreg3;
              inst->sreg2 = D.40445;
              D.40446 = inst->sreg2;
              inst->sreg1 = D.40446;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.40447 = ad_ins->dreg;
              inst->sreg1 = D.40447;
              inst->data.op[1].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40448>; else goto <D.40449>;
              <D.40448>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.40450>;
              <D.40449>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40450>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.40451 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.40451;
              ins->prev = 0B;
              D.40452 = ins->prev;
              ins->next = D.40452;
              ins->opcode = 556;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.40453 = ins->sreg3;
              ins->sreg2 = D.40453;
              D.40454 = ins->sreg2;
              ins->sreg1 = D.40454;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              if (0 != 0) goto <D.40455>; else goto <D.40456>;
              <D.40455>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.40457 = D.31048;
              D.40458 = D.40457 + 1;
              cfg->num_bblocks = D.40458;
              D.40459 = (int) D.40457;
              falsebb->block_num = D.40459;
              ins->data.op[0].target_block = next_bb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, next_bb);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40460>; else goto <D.40461>;
              <D.40460>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.40462>;
              <D.40461>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40462>:
              D.40463 = falsebb->cil_code;
              if (D.40463 != 0B) goto <D.40464>; else goto <D.40465>;
              <D.40464>:
              D.31071 = cfg->cil_offset_to_bb;
              D.40463 = falsebb->cil_code;
              D.40466 = (long int) D.40463;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.40467 = D.40466 - D.31077;
              D.40468 = (long unsigned int) D.40467;
              D.40469 = D.40468 * 8;
              D.40470 = D.31071 + D.40469;
              *D.40470 = falsebb;
              <D.40465>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40474>; else goto <D.40471>;
              <D.40474>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.40472>; else goto <D.40475>;
              <D.40475>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.40472>; else goto <D.40476>;
              <D.40476>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.40472>; else goto <D.40471>;
              <D.40472>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.40477>; else goto <D.40471>;
              <D.40477>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.40473>;
              <D.40471>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.40478>; else goto <D.40480>;
              <D.40480>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.40481>; else goto <D.40479>;
              <D.40481>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.40482>; else goto <D.40479>;
              <D.40482>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.40483>; else goto <D.40479>;
              <D.40483>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.40484>; else goto <D.40479>;
              <D.40484>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.40478>; else goto <D.40479>;
              <D.40478>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.40479>:
              <D.40473>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.40485>;
              <D.40456>:
              D.30941 = cfg->mempool;
              D.40486 = mono_mempool_alloc (D.30941, 16);
              ins->data.op[1].many_blocks = D.40486;
              D.40487 = ins->data.op[1].many_blocks;
              *D.40487 = next_bb;
              D.40487 = ins->data.op[1].many_blocks;
              D.40488 = D.40487 + 8;
              *D.40488 = 0B;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, next_bb);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40489>; else goto <D.40490>;
              <D.40489>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.40491>;
              <D.40490>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40491>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.35146 = D.31336 & 34359738368;
              if (D.35146 == 0) goto <D.40492>; else goto <D.40493>;
              <D.40492>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.40494 = D.31048;
              D.40495 = D.40494 + 1;
              cfg->num_bblocks = D.40495;
              D.40496 = (int) D.40494;
              falsebb->block_num = D.40496;
              D.40487 = ins->data.op[1].many_blocks;
              D.40488 = D.40487 + 8;
              *D.40488 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              D.40463 = falsebb->cil_code;
              if (D.40463 != 0B) goto <D.40497>; else goto <D.40498>;
              <D.40497>:
              D.31071 = cfg->cil_offset_to_bb;
              D.40463 = falsebb->cil_code;
              D.40466 = (long int) D.40463;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.40467 = D.40466 - D.31077;
              D.40468 = (long unsigned int) D.40467;
              D.40469 = D.40468 * 8;
              D.40470 = D.31071 + D.40469;
              *D.40470 = falsebb;
              <D.40498>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40502>; else goto <D.40499>;
              <D.40502>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.40500>; else goto <D.40503>;
              <D.40503>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.40500>; else goto <D.40504>;
              <D.40504>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.40500>; else goto <D.40499>;
              <D.40500>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.40505>; else goto <D.40499>;
              <D.40505>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.40501>;
              <D.40499>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.40506>; else goto <D.40508>;
              <D.40508>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.40509>; else goto <D.40507>;
              <D.40509>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.40510>; else goto <D.40507>;
              <D.40510>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.40511>; else goto <D.40507>;
              <D.40511>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.40512>; else goto <D.40507>;
              <D.40512>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.40506>; else goto <D.40507>;
              <D.40506>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.40507>:
              <D.40501>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.40513>;
              <D.40493>:
              bblock.113 = cfg->cbb;
              bblock.113->extended = 1;
              <D.40513>:
              <D.40485>:
            }
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40514>; else goto <D.40515>;
            <D.40514>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = lmf_ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            lmf_ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = lmf_ins;
            goto <D.40516>;
            <D.40515>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = lmf_ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40516>:
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.40517 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.40517;
              inst->prev = 0B;
              D.40518 = inst->prev;
              inst->next = D.40518;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.40519 = inst->sreg3;
              inst->sreg2 = D.40519;
              D.40520 = inst->sreg2;
              inst->sreg1 = D.40520;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              inst->dreg = -1;
              D.40521 = lmf_ins->dreg;
              inst->sreg1 = D.40521;
              inst->data.op[1].const_val = 0;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40522>; else goto <D.40523>;
              <D.40522>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.40524>;
              <D.40523>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40524>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30941 = cfg->mempool;
              ins = mono_mempool_alloc (D.30941, 80);
              ins->data.op[1].const_val = 0;
              D.40525 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.40525;
              ins->prev = 0B;
              D.40526 = ins->prev;
              ins->next = D.40526;
              ins->opcode = 556;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.40527 = ins->sreg3;
              ins->sreg2 = D.40527;
              D.40528 = ins->sreg2;
              ins->sreg1 = D.40528;
              D.31162 = cfg->ip;
              ins->cil_code = D.31162;
              if (0 != 0) goto <D.40529>; else goto <D.40530>;
              <D.40529>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.40531 = D.31048;
              D.40532 = D.40531 + 1;
              cfg->num_bblocks = D.40532;
              D.40533 = (int) D.40531;
              falsebb->block_num = D.40533;
              ins->data.op[0].target_block = next_bb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, next_bb);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40534>; else goto <D.40535>;
              <D.40534>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.40536>;
              <D.40535>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40536>:
              D.40537 = falsebb->cil_code;
              if (D.40537 != 0B) goto <D.40538>; else goto <D.40539>;
              <D.40538>:
              D.31071 = cfg->cil_offset_to_bb;
              D.40537 = falsebb->cil_code;
              D.40540 = (long int) D.40537;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.40541 = D.40540 - D.31077;
              D.40542 = (long unsigned int) D.40541;
              D.40543 = D.40542 * 8;
              D.40544 = D.31071 + D.40543;
              *D.40544 = falsebb;
              <D.40539>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40548>; else goto <D.40545>;
              <D.40548>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.40546>; else goto <D.40549>;
              <D.40549>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.40546>; else goto <D.40550>;
              <D.40550>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.40546>; else goto <D.40545>;
              <D.40546>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.40551>; else goto <D.40545>;
              <D.40551>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.40547>;
              <D.40545>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.40552>; else goto <D.40554>;
              <D.40554>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.40555>; else goto <D.40553>;
              <D.40555>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.40556>; else goto <D.40553>;
              <D.40556>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.40557>; else goto <D.40553>;
              <D.40557>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.40558>; else goto <D.40553>;
              <D.40558>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.40552>; else goto <D.40553>;
              <D.40552>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.40553>:
              <D.40547>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.40559>;
              <D.40530>:
              D.30941 = cfg->mempool;
              D.40560 = mono_mempool_alloc (D.30941, 16);
              ins->data.op[1].many_blocks = D.40560;
              D.40561 = ins->data.op[1].many_blocks;
              *D.40561 = next_bb;
              D.40561 = ins->data.op[1].many_blocks;
              D.40562 = D.40561 + 8;
              *D.40562 = 0B;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, next_bb);
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40563>; else goto <D.40564>;
              <D.40563>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = ins;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              ins->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              goto <D.40565>;
              <D.40564>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = ins;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40565>:
              D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.35146 = D.31336 & 34359738368;
              if (D.35146 == 0) goto <D.40566>; else goto <D.40567>;
              <D.40566>:
              D.30941 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30941, 296);
              D.31048 = cfg->num_bblocks;
              D.40568 = D.31048;
              D.40569 = D.40568 + 1;
              cfg->num_bblocks = D.40569;
              D.40570 = (int) D.40568;
              falsebb->block_num = D.40570;
              D.40561 = ins->data.op[1].many_blocks;
              D.40562 = D.40561 + 8;
              *D.40562 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              D.40537 = falsebb->cil_code;
              if (D.40537 != 0B) goto <D.40571>; else goto <D.40572>;
              <D.40571>:
              D.31071 = cfg->cil_offset_to_bb;
              D.40537 = falsebb->cil_code;
              D.40540 = (long int) D.40537;
              D.31076 = cfg->cil_start;
              D.31077 = (long int) D.31076;
              D.40541 = D.40540 - D.31077;
              D.40542 = (long unsigned int) D.40541;
              D.40543 = D.40542 * 8;
              D.40544 = D.31071 + D.40543;
              *D.40544 = falsebb;
              <D.40572>:
              D.31108 = cfg->real_offset;
              falsebb->real_offset = D.31108;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40576>; else goto <D.40573>;
              <D.40576>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 <= 9) goto <D.40574>; else goto <D.40577>;
              <D.40577>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 <= 9) goto <D.40574>; else goto <D.40578>;
              <D.40578>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 <= 9) goto <D.40574>; else goto <D.40573>;
              <D.40574>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              D.35130 = *D.35129;
              if (D.35130 == 0B) goto <D.40579>; else goto <D.40573>;
              <D.40579>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35128 = D.31191->data.op[1].many_blocks;
              D.35129 = D.35128 + 8;
              *D.35129 = falsebb;
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              goto <D.40575>;
              <D.40573>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 == 0B) goto <D.40580>; else goto <D.40582>;
              <D.40582>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 442) goto <D.40583>; else goto <D.40581>;
              <D.40583>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              if (D.35122 != 759) goto <D.40584>; else goto <D.40581>;
              <D.40584>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35123 = D.35122 + 64985;
              if (D.35123 > 9) goto <D.40585>; else goto <D.40581>;
              <D.40585>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35125 = D.35122 + 64878;
              if (D.35125 > 9) goto <D.40586>; else goto <D.40581>;
              <D.40586>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.35122 = D.31191->opcode;
              D.35127 = D.35122 + 64888;
              if (D.35127 > 9) goto <D.40580>; else goto <D.40581>;
              <D.40580>:
              bblock.113 = cfg->cbb;
              mono_link_bblock (cfg, bblock.113, falsebb);
              <D.40581>:
              <D.40575>:
              bblock.113 = cfg->cbb;
              bblock.113->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.40587>;
              <D.40567>:
              bblock.113 = cfg->cbb;
              bblock.113->extended = 1;
              <D.40587>:
              <D.40559>:
            }
            <D.40436>:
            <D.40434>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.31337 = D.31336 & 274877906944;
            if (D.31337 != 0) goto <D.40588>; else goto <D.40589>;
            <D.40588>:
            D.30941 = cfg->mempool;
            D.40590 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.40590;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->data.op[1].const_val = 0;
            D.40592 = D.40591->data.op[1].const_val;
            D.40591->data.op[0].const_val = D.40592;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->prev = 0B;
            D.40593 = D.40591->prev;
            D.40591->next = D.40593;
            D.40591 = args[0];
            D.40591->opcode = 363;
            D.40591 = args[0];
            D.40591->flags = 0;
            D.40591 = args[0];
            D.40591->type = 0;
            D.40591 = args[0];
            D.40591->dreg = -1;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->sreg3 = -1;
            D.40594 = D.40591->sreg3;
            D.40591->sreg2 = D.40594;
            D.40595 = D.40591->sreg2;
            D.40591->sreg1 = D.40595;
            D.40591 = args[0];
            D.31162 = cfg->ip;
            D.40591->cil_code = D.31162;
            D.40591 = args[0];
            D.40591->data.op[0].p = 0B;
            D.40591 = args[0];
            D.40591->type = 3;
            D.40591 = args[0];
            D.40596 = alloc_dreg (cfg, 3);
            D.40597 = (int) D.40596;
            D.40591->dreg = D.40597;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40598>; else goto <D.40599>;
            <D.40598>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40591 = args[0];
            D.31191->next = D.40591;
            D.40591 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40591->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.40591 = args[0];
            bblock.113->last_ins = D.40591;
            goto <D.40600>;
            <D.40599>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.40591 = args[0];
            bblock.113->last_ins = D.40591;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40600>:
            goto <D.40601>;
            <D.40589>:
            D.30941 = cfg->mempool;
            D.40602 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.40602;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->data.op[1].const_val = 0;
            D.40592 = D.40591->data.op[1].const_val;
            D.40591->data.op[0].const_val = D.40592;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->prev = 0B;
            D.40593 = D.40591->prev;
            D.40591->next = D.40593;
            D.40591 = args[0];
            D.40591->opcode = 363;
            D.40591 = args[0];
            D.40591->flags = 0;
            D.40591 = args[0];
            D.40591->type = 0;
            D.40591 = args[0];
            D.40591->dreg = -1;
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591 = args[0];
            D.40591->sreg3 = -1;
            D.40594 = D.40591->sreg3;
            D.40591->sreg2 = D.40594;
            D.40595 = D.40591->sreg2;
            D.40591->sreg1 = D.40595;
            D.40591 = args[0];
            D.31162 = cfg->ip;
            D.40591->cil_code = D.31162;
            D.40591 = args[0];
            D.30966 = cfg->domain;
            D.40591->data.op[0].p = D.30966;
            D.40591 = args[0];
            D.40591->type = 3;
            D.40591 = args[0];
            D.40603 = alloc_dreg (cfg, 3);
            D.40604 = (int) D.40603;
            D.40591->dreg = D.40604;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40605>; else goto <D.40606>;
            <D.40605>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40591 = args[0];
            D.31191->next = D.40591;
            D.40591 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40591->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.40591 = args[0];
            bblock.113->last_ins = D.40591;
            goto <D.40607>;
            <D.40606>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.40591 = args[0];
            bblock.113->last_ins = D.40591;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40607>:
            <D.40601>:
            ins = mono_emit_jit_icall (cfg, mono_jit_thread_attach, &args);
            {
              struct MonoInst * inst;

              D.30941 = cfg->mempool;
              inst = mono_mempool_alloc (D.30941, 80);
              inst->data.op[1].const_val = 0;
              D.40608 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.40608;
              inst->prev = 0B;
              D.40609 = inst->prev;
              inst->next = D.40609;
              inst->opcode = 424;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.40610 = inst->sreg3;
              inst->sreg2 = D.40610;
              D.40611 = inst->sreg2;
              inst->sreg1 = D.40611;
              D.31162 = cfg->ip;
              inst->cil_code = D.31162;
              D.40428 = cfg->orig_domain_var;
              D.40429 = D.40428->dreg;
              inst->dreg = D.40429;
              D.31356 = ins->dreg;
              inst->sreg1 = D.31356;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              if (D.31191 != 0B) goto <D.40612>; else goto <D.40613>;
              <D.40612>:
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              D.31191->next = inst;
              bblock.113 = cfg->cbb;
              D.31191 = bblock.113->last_ins;
              inst->prev = D.31191;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              goto <D.40614>;
              <D.40613>:
              bblock.113 = cfg->cbb;
              bblock.113 = cfg->cbb;
              bblock.113->last_ins = inst;
              D.31191 = bblock.113->last_ins;
              bblock.113->code = D.31191;
              <D.40614>:
            }
            if (next_bb != 0B) goto <D.40615>; else goto <D.40616>;
            <D.40615>:
            D.40617 = next_bb->cil_code;
            if (D.40617 != 0B) goto <D.40618>; else goto <D.40619>;
            <D.40618>:
            D.31071 = cfg->cil_offset_to_bb;
            D.40617 = next_bb->cil_code;
            D.40620 = (long int) D.40617;
            D.31076 = cfg->cil_start;
            D.31077 = (long int) D.31076;
            D.40621 = D.40620 - D.31077;
            D.40622 = (long unsigned int) D.40621;
            D.40623 = D.40622 * 8;
            D.40624 = D.31071 + D.40623;
            *D.40624 = next_bb;
            <D.40619>:
            D.31108 = cfg->real_offset;
            next_bb->real_offset = D.31108;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40628>; else goto <D.40625>;
            <D.40628>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35123 = D.35122 + 64985;
            if (D.35123 <= 9) goto <D.40626>; else goto <D.40629>;
            <D.40629>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35125 = D.35122 + 64878;
            if (D.35125 <= 9) goto <D.40626>; else goto <D.40630>;
            <D.40630>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35127 = D.35122 + 64888;
            if (D.35127 <= 9) goto <D.40626>; else goto <D.40625>;
            <D.40626>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35128 = D.31191->data.op[1].many_blocks;
            D.35129 = D.35128 + 8;
            D.35130 = *D.35129;
            if (D.35130 == 0B) goto <D.40631>; else goto <D.40625>;
            <D.40631>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35128 = D.31191->data.op[1].many_blocks;
            D.35129 = D.35128 + 8;
            *D.35129 = next_bb;
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, next_bb);
            goto <D.40627>;
            <D.40625>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 == 0B) goto <D.40632>; else goto <D.40634>;
            <D.40634>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            if (D.35122 != 442) goto <D.40635>; else goto <D.40633>;
            <D.40635>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            if (D.35122 != 759) goto <D.40636>; else goto <D.40633>;
            <D.40636>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35123 = D.35122 + 64985;
            if (D.35123 > 9) goto <D.40637>; else goto <D.40633>;
            <D.40637>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35125 = D.35122 + 64878;
            if (D.35125 > 9) goto <D.40638>; else goto <D.40633>;
            <D.40638>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.35122 = D.31191->opcode;
            D.35127 = D.35122 + 64888;
            if (D.35127 > 9) goto <D.40632>; else goto <D.40633>;
            <D.40632>:
            bblock.113 = cfg->cbb;
            mono_link_bblock (cfg, bblock.113, next_bb);
            <D.40633>:
            <D.40627>:
            bblock.113 = cfg->cbb;
            bblock.113->next_bb = next_bb;
            cfg->cbb = next_bb;
            bblock.113 = cfg->cbb;
            bblock = bblock.113;
            <D.40616>:
            ip = ip + 2;
            goto <D.28614>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28676>:
      {
        struct MonoInst * args[16];

        try
          {
            D.40639 = alloc_ireg (cfg);
            dreg = (int) D.40639;
            D.30941 = cfg->mempool;
            D.40640 = mono_mempool_alloc (D.30941, 80);
            args[0] = D.40640;
            D.40641 = args[0];
            D.40641 = args[0];
            D.40641->data.op[1].const_val = 0;
            D.40642 = D.40641->data.op[1].const_val;
            D.40641->data.op[0].const_val = D.40642;
            D.40641 = args[0];
            D.40641 = args[0];
            D.40641->prev = 0B;
            D.40643 = D.40641->prev;
            D.40641->next = D.40643;
            D.40641 = args[0];
            D.40641->opcode = 424;
            D.40641 = args[0];
            D.40641->flags = 0;
            D.40641 = args[0];
            D.40641->type = 0;
            D.40641 = args[0];
            D.40641->dreg = -1;
            D.40641 = args[0];
            D.40641 = args[0];
            D.40641 = args[0];
            D.40641->sreg3 = -1;
            D.40644 = D.40641->sreg3;
            D.40641->sreg2 = D.40644;
            D.40645 = D.40641->sreg2;
            D.40641->sreg1 = D.40645;
            D.40641 = args[0];
            D.31162 = cfg->ip;
            D.40641->cil_code = D.31162;
            D.40641 = args[0];
            D.40641->dreg = dreg;
            D.40641 = args[0];
            D.40428 = cfg->orig_domain_var;
            D.40429 = D.40428->dreg;
            D.40641->sreg1 = D.40429;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.40646>; else goto <D.40647>;
            <D.40646>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40641 = args[0];
            D.31191->next = D.40641;
            D.40641 = args[0];
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.40641->prev = D.31191;
            bblock.113 = cfg->cbb;
            D.40641 = args[0];
            bblock.113->last_ins = D.40641;
            goto <D.40648>;
            <D.40647>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            D.40641 = args[0];
            bblock.113->last_ins = D.40641;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.40648>:
            mono_emit_jit_icall (cfg, mono_jit_set_domain, &args);
            ip = ip + 2;
            goto <D.28614>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28678>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      monoeg_g_log (0B, 4, "opcode 0x%02x 0x%02x not handled", 240, D.32296);
      <D.28679>:
      goto <D.28679>;
      <D.28614>:
      goto <D.27857>;
      <D.28680>:
      D.31968 = ip + 2;
      if (D.31968 > end) goto <D.40649>; else goto <D.40650>;
      <D.40649>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40651>; else goto <D.40652>;
      <D.40651>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40653>; else goto <D.40654>;
      <D.40653>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40654>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40652>:
      D.40655 = mini_get_debug_options ();
      D.40656 = D.40655->break_on_unverified;
      if (D.40656 != 0) goto <D.40657>; else goto unverified;
      <D.40657>:
      raise (5);
      <D.40650>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      switch (D.32296) <default: <D.28761>, case 0: <D.28681>, case 1: <D.28687>, case 2: <D.28688>, case 3: <D.28689>, case 4: <D.28690>, case 5: <D.28691>, case 6: <D.28693>, case 7: <D.28704>, case 8: <D.28756>, case 9: <D.28706>, case 10: <D.28707>, case 11: <D.28710>, case 12: <D.28711>, case 13: <D.28712>, case 14: <D.28716>, case 15: <D.28717>, case 16: <D.28757>, case 17: <D.28718>, case 18: <D.28726>, case 19: <D.28727>, case 20: <D.28728>, case 21: <D.28729>, case 22: <D.28731>, case 23: <D.28732>, case 24: <D.28733>, case 25: <D.28737>, case 26: <D.28738>, case 27: <D.28759>, case 28: <D.28745>, case 29: <D.28750>, case 30: <D.28755>, case 34: <D.28758>, case 36: <D.28760>>
      <D.28681>:
      {
        struct MonoInst * addr;
        struct MonoInst * vtvar;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.40658>; else goto <D.40659>;
        <D.40658>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40660>; else goto <D.40661>;
        <D.40660>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40662>; else goto <D.40663>;
        <D.40662>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40663>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40661>:
        D.40664 = mini_get_debug_options ();
        D.40665 = D.40664->break_on_unverified;
        if (D.40665 != 0) goto <D.40666>; else goto unverified;
        <D.40666>:
        raise (5);
        <D.40659>:
        D.40667 = mono_defaults.argumenthandle_class;
        D.40668 = &D.40667->byval_arg;
        vtvar = mono_compile_create_var (cfg, D.40668, 329);
        D.30941 = cfg->mempool;
        addr = mono_mempool_alloc (D.30941, 80);
        addr->data.op[1].const_val = 0;
        D.40669 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.40669;
        addr->prev = 0B;
        D.40670 = addr->prev;
        addr->next = D.40670;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.40671 = addr->sreg3;
        addr->sreg2 = D.40671;
        D.40672 = addr->sreg2;
        addr->sreg1 = D.40672;
        D.31162 = cfg->ip;
        addr->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        addr->data.op[0].p = D.40677;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40678 = D.40677->flags;
        D.40679 = D.40678 | 16;
        D.40677->flags = D.40679;
        addr->type = 5;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40680 = D.40677->klass;
        addr->klass = D.40680;
        D.40681 = alloc_dreg (cfg, 5);
        D.40682 = (int) D.40681;
        addr->dreg = D.40682;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.40683>; else goto <D.40684>;
        <D.40683>:
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40685 = D.40677->data.op[1].vtype;
        D.40686 = mini_is_gsharedvt_variable_type (cfg, D.40685);
        if (D.40686 != 0) goto <D.40687>; else goto <D.40688>;
        <D.40687>:
        handle_gsharedvt_ldaddr (cfg);
        <D.40688>:
        <D.40684>:
        if (0 != 0) goto <D.40689>; else goto <D.40690>;
        <D.40689>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31695 = cfg->varinfo;
          D.40673 = vtvar->data.op[0].const_val;
          D.40674 = (long unsigned int) D.40673;
          D.40675 = D.40674 * 8;
          D.40676 = D.31695 + D.40675;
          D.40677 = *D.40676;
          D.40692 = D.40677->dreg;
          D.40693 = D.40692 + 1;
          D.40694 = (unsigned int) D.40693;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.40694 < D.32058) goto <D.40695>; else goto <D.40696>;
          <D.40695>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.40673 = vtvar->data.op[0].const_val;
          D.40674 = (long unsigned int) D.40673;
          D.40675 = D.40674 * 8;
          D.40676 = D.31695 + D.40675;
          D.40677 = *D.40676;
          D.40692 = D.40677->dreg;
          D.40697 = (sizetype) D.40692;
          D.40698 = D.40697 + 1;
          D.40699 = D.40698 * 8;
          D.40700 = D.32061 + D.40699;
          iftmp.315 = *D.40700;
          goto <D.40701>;
          <D.40696>:
          iftmp.315 = 0B;
          <D.40701>:
          var1 = iftmp.315;
          D.31695 = cfg->varinfo;
          D.40673 = vtvar->data.op[0].const_val;
          D.40674 = (long unsigned int) D.40673;
          D.40675 = D.40674 * 8;
          D.40676 = D.31695 + D.40675;
          D.40677 = *D.40676;
          D.40692 = D.40677->dreg;
          D.40703 = D.40692 + 2;
          D.40704 = (unsigned int) D.40703;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.40704 < D.32058) goto <D.40705>; else goto <D.40706>;
          <D.40705>:
          D.32061 = cfg->vreg_to_inst;
          D.31695 = cfg->varinfo;
          D.40673 = vtvar->data.op[0].const_val;
          D.40674 = (long unsigned int) D.40673;
          D.40675 = D.40674 * 8;
          D.40676 = D.31695 + D.40675;
          D.40677 = *D.40676;
          D.40692 = D.40677->dreg;
          D.40697 = (sizetype) D.40692;
          D.40707 = D.40697 + 2;
          D.40708 = D.40707 * 8;
          D.40709 = D.32061 + D.40708;
          iftmp.316 = *D.40709;
          goto <D.40710>;
          <D.40706>:
          iftmp.316 = 0B;
          <D.40710>:
          var2 = iftmp.316;
          D.40711 = var1 == 0B;
          D.40712 = (long int) D.40711;
          D.40713 = __builtin_expect (D.40712, 0);
          if (D.40713 != 0) goto <D.40714>; else goto <D.40715>;
          <D.40714>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11394, "var1");
          <D.40715>:
          D.40716 = var2 == 0B;
          D.40717 = (long int) D.40716;
          D.40718 = __builtin_expect (D.40717, 0);
          if (D.40718 != 0) goto <D.40719>; else goto <D.40720>;
          <D.40719>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11394, "var2");
          <D.40720>:
          D.40721 = var1->flags;
          D.40722 = D.40721 | 16;
          var1->flags = D.40722;
          D.40723 = var2->flags;
          D.40724 = D.40723 | 16;
          var2->flags = D.40724;
        }
        <D.40690>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.40725>; else goto <D.40726>;
        <D.40725>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = addr;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        addr->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = addr;
        goto <D.40727>;
        <D.40726>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = addr;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.40727>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 373;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = -1;
        D.40728 = addr->dreg;
        ins->sreg1 = D.40728;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.40729>; else goto <D.40730>;
        <D.40729>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.40731>;
        <D.40730>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.40731>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40685 = D.40677->data.op[1].vtype;
        D.40732 = mono_type_to_regmove (cfg, D.40685);
        D.40733 = (short unsigned int) D.40732;
        ins->opcode = D.40733;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40685 = D.40677->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.40685, ins);
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40680 = D.40677->klass;
        ins->klass = D.40680;
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40692 = D.40677->dreg;
        ins->sreg1 = D.40692;
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.40734 = alloc_dreg (cfg, D.31706);
        D.40735 = (int) D.40734;
        ins->dreg = D.40735;
        D.31709 = ins->opcode;
        if (D.31709 == 427) goto <D.40736>; else goto <D.40737>;
        <D.40736>:
        D.31695 = cfg->varinfo;
        D.40673 = vtvar->data.op[0].const_val;
        D.40674 = (long unsigned int) D.40673;
        D.40675 = D.40674 * 8;
        D.40676 = D.31695 + D.40675;
        D.40677 = *D.40676;
        D.40685 = D.40677->data.op[1].vtype;
        D.40738 = mono_class_from_mono_type (D.40685);
        ins->klass = D.40738;
        <D.40737>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.40739>; else goto <D.40740>;
        <D.40739>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.40741>;
        <D.40740>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.40741>:
        ins->type = 7;
        D.40667 = mono_defaults.argumenthandle_class;
        ins->klass = D.40667;
        sp.317 = sp;
        sp = sp.317 + 8;
        *sp.317 = ins;
        ip = ip + 2;
        goto <D.28686>;
      }
      <D.28687>:
      <D.28688>:
      <D.28689>:
      <D.28690>:
      <D.28691>:
      {
        struct MonoInst * cmp;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 15) goto <D.40743>; else goto <D.40744>;
        <D.40743>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40745>; else goto <D.40746>;
        <D.40745>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40747>; else goto <D.40748>;
        <D.40747>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40748>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40746>:
        D.40749 = mini_get_debug_options ();
        D.40750 = D.40749->break_on_unverified;
        if (D.40750 != 0) goto <D.40751>; else goto unverified;
        <D.40751>:
        raise (5);
        <D.40744>:
        D.30941 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30941, 80);
        cmp->data.op[1].const_val = 0;
        D.40752 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.40752;
        cmp->prev = 0B;
        D.40753 = cmp->prev;
        cmp->next = D.40753;
        D.31987 = ip + 1;
        D.31988 = *D.31987;
        D.40754 = (short unsigned int) D.31988;
        D.40755 = D.40754 + 445;
        cmp->opcode = D.40755;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.40756 = cmp->sreg3;
        cmp->sreg2 = D.40756;
        D.40757 = cmp->sreg2;
        cmp->sreg1 = D.40757;
        D.31162 = cfg->ip;
        cmp->cil_code = D.31162;
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.40758 = cmp->opcode;
        ins->opcode = D.40758;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        sp = sp + 18446744073709551600;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        cmp->sreg1 = D.32139;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        D.33091 = D.33090->dreg;
        cmp->sreg2 = D.33091;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (cmp, D.31957, D.33090);
        D.40759 = cmp->type;
        if (D.40759 == 0) goto <D.40760>; else goto <D.40761>;
        <D.40760>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.40762>; else goto <D.40763>;
        <D.40762>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.40764>; else goto <D.40765>;
        <D.40764>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40765>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40763>:
        D.40766 = mini_get_debug_options ();
        D.40767 = D.40766->break_on_unverified;
        if (D.40767 != 0) goto <D.40768>; else goto unverified;
        <D.40768>:
        raise (5);
        <D.40761>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 2) goto <D.40769>; else goto <D.40772>;
        <D.40772>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 3) goto <D.40769>; else goto <D.40773>;
        <D.40773>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 6) goto <D.40769>; else goto <D.40774>;
        <D.40774>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 5) goto <D.40769>; else goto <D.40770>;
        <D.40769>:
        cmp->opcode = 325;
        goto <D.40771>;
        <D.40770>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 == 4) goto <D.40775>; else goto <D.40776>;
        <D.40775>:
        cmp->opcode = 324;
        goto <D.40777>;
        <D.40776>:
        cmp->opcode = 326;
        <D.40777>:
        <D.40771>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.40778>; else goto <D.40779>;
        <D.40778>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = cmp;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        cmp->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        goto <D.40780>;
        <D.40779>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = cmp;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.40780>:
        ins->type = 1;
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.40781 = alloc_dreg (cfg, D.31706);
        D.40782 = (int) D.40781;
        ins->dreg = D.40782;
        D.31957 = *sp;
        D.33089 = sp + 8;
        D.33090 = *D.33089;
        type_from_op (ins, D.31957, D.33090);
        D.40758 = cmp->opcode;
        if (D.40758 == 324) goto <D.40783>; else goto <D.40784>;
        <D.40783>:
        cmp->opcode = 316;
        D.40785 = cmp->sreg1;
        ins->sreg1 = D.40785;
        D.40757 = cmp->sreg2;
        ins->sreg2 = D.40757;
        <D.40784>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.40786>; else goto <D.40787>;
        <D.40786>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.40788>;
        <D.40787>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.40788>:
        sp.318 = sp;
        sp = sp.318 + 8;
        *sp.318 = ins;
        ip = ip + 2;
        goto <D.28686>;
      }
      <D.28693>:
      {
        struct MonoInst * argconst;
        struct MonoMethod * cil_method;

        try
          {
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.31641 = header->max_stack;
            D.31863 = (long int) D.31641;
            if (D.31731 >= D.31863) goto <D.40790>; else goto <D.40791>;
            <D.40790>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.40792>; else goto <D.40793>;
            <D.40792>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.40794>; else goto <D.40795>;
            <D.40794>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40795>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40793>:
            D.40796 = mini_get_debug_options ();
            D.40797 = D.40796->break_on_unverified;
            if (D.40797 != 0) goto <D.40798>; else goto unverified;
            <D.40798>:
            raise (5);
            <D.40791>:
            D.35709 = ip + 6;
            if (D.35709 > end) goto <D.40799>; else goto <D.40800>;
            <D.40799>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.40801>; else goto <D.40802>;
            <D.40801>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.40803>; else goto <D.40804>;
            <D.40803>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40804>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40802>:
            D.40805 = mini_get_debug_options ();
            D.40806 = D.40805->break_on_unverified;
            if (D.40806 != 0) goto <D.40807>; else goto unverified;
            <D.40807>:
            raise (5);
            <D.40800>:
            D.40310 = ip + 2;
            D.40311 = *D.40310;
            n = (int) D.40311;
            n.161 = (unsigned int) n;
            cmethod = mini_get_method (cfg, method, n.161, 0B, generic_context);
            if (cmethod == 0B) goto <D.40808>; else goto <D.40810>;
            <D.40810>:
            D.40811 = mono_loader_get_last_error ();
            if (D.40811 != 0B) goto <D.40808>; else goto <D.40809>;
            <D.40808>:
            D.40812 = mini_get_debug_options ();
            D.40813 = D.40812->break_on_unverified;
            if (D.40813 != 0) goto <D.40814>; else goto load_error;
            <D.40814>:
            raise (5);
            <D.40809>:
            D.32828 = cmethod->klass;
            mono_class_init (D.32828);
            n.161 = (unsigned int) n;
            mono_save_token_info (cfg, image, n.161, cmethod);
            context_used = mini_method_check_context_used (cfg, cmethod);
            cil_method = cmethod;
            if (dont_verify == 0) goto <D.40815>; else goto <D.40816>;
            <D.40815>:
            D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.32845 = D.31336 & 70368744177664;
            if (D.32845 == 0) goto <D.40817>; else goto <D.40818>;
            <D.40817>:
            D.40819 = mono_method_can_access_method (method, cmethod);
            if (D.40819 == 0) goto <D.40820>; else goto <D.40821>;
            <D.40820>:
            {
              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.40822 = monoeg_g_strdup_printf ("Method `%s\' is inaccessible from method `%s\'\n", cil_method_fname, method_fname);
              cfg->exception_message = D.40822;
              monoeg_g_free (method_fname);
              monoeg_g_free (cil_method_fname);
              goto exception_exit;
            }
            <D.40821>:
            <D.40818>:
            <D.40816>:
            D.40823 = mono_security_get_mode ();
            if (D.40823 == 2) goto <D.40824>; else goto <D.40825>;
            <D.40824>:
            D.40826 = check_linkdemand (cfg, method, cmethod);
            if (D.40826 != 0) goto <D.40827>; else goto <D.40828>;
            <D.40827>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.40829>; else goto <D.40830>;
            <D.40829>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.40831>; else goto <D.40832>;
            <D.40831>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.40833>; else goto <D.40834>;
            <D.40833>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.40834>:
            goto inline_failure;
            <D.40832>:
            <D.40830>:
            <D.40828>:
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.40835>;
            <D.40835>:
            goto <D.40836>;
            <D.40825>:
            D.40837 = mono_security_get_mode ();
            if (D.40837 == 1) goto <D.40838>; else goto <D.40839>;
            <D.40838>:
            bblock.70 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.70, ip);
            <D.40839>:
            <D.40836>:
            if (sp > stack_start) goto <D.40840>; else goto <D.40841>;
            <D.40840>:
            D.40842 = ip + 11;
            if (D.40842 < end) goto <D.40843>; else goto <D.40844>;
            <D.40843>:
            bblock.70 = bblock;
            D.38325 = ip + 6;
            D.40845 = ip_in_bb (cfg, bblock.70, D.38325);
            if (D.40845 != 0) goto <D.40846>; else goto <D.40847>;
            <D.40846>:
            D.35709 = ip + 6;
            D.35710 = *D.35709;
            if (D.35710 == 115) goto <D.40848>; else goto <D.40849>;
            <D.40848>:
            {
              struct MonoMethod * ctor_method;

              D.40850 = ip + 7;
              D.40851 = *D.40850;
              ctor_method = mini_get_method (cfg, method, D.40851, 0B, generic_context);
              if (ctor_method != 0B) goto <D.40852>; else goto <D.40853>;
              <D.40852>:
              D.40854 = ctor_method->klass;
              D.40855 = D.40854->parent;
              D.33302 = mono_defaults.multicastdelegate_class;
              if (D.40855 == D.33302) goto <D.40856>; else goto <D.40857>;
              <D.40856>:
              {
                struct MonoInst * target_ins;
                struct MonoMethod * invoke;
                int invoke_context_used;

                D.40854 = ctor_method->klass;
                invoke = mono_get_delegate_invoke (D.40854);
                if (invoke == 0B) goto <D.40858>; else goto <D.40860>;
                <D.40860>:
                D.40861 = mono_method_signature (invoke);
                if (D.40861 == 0B) goto <D.40858>; else goto <D.40859>;
                <D.40858>:
                D.40862 = mini_get_debug_options ();
                D.40863 = D.40862->break_on_unverified;
                if (D.40863 != 0) goto <D.40864>; else goto load_error;
                <D.40864>:
                raise (5);
                <D.40859>:
                invoke_context_used = mini_method_check_context_used (cfg, invoke);
                target_ins = MEM[(struct MonoInst * *)sp + -8B];
                D.40865 = mono_security_get_mode ();
                if (D.40865 == 1) goto <D.40866>; else goto <D.40867>;
                <D.40866>:
                bblock.70 = bblock;
                ensure_method_is_allowed_to_call_method (cfg, method, ctor_method, bblock.70, ip);
                <D.40867>:
                D.32864 = cmethod->flags;
                D.32865 = (int) D.32864;
                D.40868 = D.32865 & 16;
                if (D.40868 == 0) goto <D.40869>; else goto <D.40870>;
                <D.40869>:
                D.40871 = mono_method_signature (invoke);
                D.40872 = D.40871->param_count;
                D.40873 = mono_method_signature (cmethod);
                D.40874 = D.40873->param_count;
                if (D.40872 == D.40874) goto <D.40875>; else goto <D.40876>;
                <D.40875>:
                {
                  struct MonoInst * inst;

                  D.30941 = cfg->mempool;
                  inst = mono_mempool_alloc (D.30941, 80);
                  inst->data.op[1].const_val = 0;
                  D.40877 = inst->data.op[1].const_val;
                  inst->data.op[0].const_val = D.40877;
                  inst->prev = 0B;
                  D.40878 = inst->prev;
                  inst->next = D.40878;
                  inst->opcode = 323;
                  inst->flags = 0;
                  inst->type = 0;
                  inst->dreg = -1;
                  inst->sreg3 = -1;
                  D.40879 = inst->sreg3;
                  inst->sreg2 = D.40879;
                  D.40880 = inst->sreg2;
                  inst->sreg1 = D.40880;
                  D.31162 = cfg->ip;
                  inst->cil_code = D.31162;
                  inst->dreg = -1;
                  D.40881 = target_ins->dreg;
                  inst->sreg1 = D.40881;
                  inst->data.op[1].const_val = 0;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.40882>; else goto <D.40883>;
                  <D.40882>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = inst;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  inst->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = inst;
                  goto <D.40884>;
                  <D.40883>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = inst;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.40884>:
                }
                {
                  struct MonoInst * inst;

                  D.30941 = cfg->mempool;
                  inst = mono_mempool_alloc (D.30941, 80);
                  inst->data.op[1].const_val = 0;
                  D.40885 = inst->data.op[1].const_val;
                  inst->data.op[0].const_val = D.40885;
                  inst->prev = 0B;
                  D.40886 = inst->prev;
                  inst->next = D.40886;
                  inst->opcode = 451;
                  inst->flags = 0;
                  inst->type = 0;
                  inst->dreg = -1;
                  inst->sreg3 = -1;
                  D.40887 = inst->sreg3;
                  inst->sreg2 = D.40887;
                  D.40888 = inst->sreg2;
                  inst->sreg1 = D.40888;
                  D.31162 = cfg->ip;
                  inst->cil_code = D.31162;
                  inst->data.op[1].p = "ArgumentException";
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  if (D.31191 != 0B) goto <D.40889>; else goto <D.40890>;
                  <D.40889>:
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  D.31191->next = inst;
                  bblock.113 = cfg->cbb;
                  D.31191 = bblock.113->last_ins;
                  inst->prev = D.31191;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = inst;
                  goto <D.40891>;
                  <D.40890>:
                  bblock.113 = cfg->cbb;
                  bblock.113 = cfg->cbb;
                  bblock.113->last_ins = inst;
                  D.31191 = bblock.113->last_ins;
                  bblock.113->code = D.31191;
                  <D.40891>:
                }
                <D.40876>:
                <D.40870>:
                if (invoke_context_used == 0) goto <D.40892>; else goto <D.40893>;
                <D.40892>:
                ip = ip + 6;
                D.31021 = cfg->verbose_level;
                if (D.31021 > 3) goto <D.40894>; else goto <D.40895>;
                <D.40894>:
                bblock.70 = bblock;
                D.31836 = bblock.70->block_num;
                sp.77 = (long int) sp;
                stack_start.78 = (long int) stack_start;
                D.31730 = sp.77 - stack_start.78;
                D.31731 = D.31730 /[ex] 8;
                D.31732 = (int) D.31731;
                D.40896 = mono_disasm_code_one (0B, method, ip, 0B);
                monoeg_g_print ("converting (in B%d: stack: %d) %s", D.31836, D.31732, D.40896);
                <D.40895>:
                sp = sp + 18446744073709551608;
                D.40854 = ctor_method->klass;
                D.40897 = handle_delegate_ctor (cfg, D.40854, target_ins, cmethod, context_used);
                *sp = D.40897;
                D.31510 = cfg->exception_type;
                if (D.31510 != 0) goto exception_exit; else goto <D.40898>;
                <D.40898>:
                ip = ip + 5;
                sp = sp + 8;
                goto <D.28686>;
                <D.40893>:
              }
              <D.40857>:
              <D.40853>:
            }
            <D.40849>:
            <D.40847>:
            <D.40844>:
            <D.40841>:
            argconst.319 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            argconst = argconst.319;
            ins = mono_emit_jit_icall (cfg, mono_ldftn, &argconst);
            sp.320 = sp;
            sp = sp.320 + 8;
            *sp.320 = ins;
            ip = ip + 6;
            num_calls.321 = num_calls;
            num_calls = num_calls.321 + 1;
            D.40902 = num_calls.321 * 10;
            inline_costs = D.40902 + inline_costs;
            goto <D.28686>;
          }
        finally
          {
            argconst = {CLOBBER};
          }
      }
      <D.28704>:
      {
        struct MonoInst * args[2];

        try
          {
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            if (D.31730 <= 7) goto <D.40903>; else goto <D.40904>;
            <D.40903>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.40905>; else goto <D.40906>;
            <D.40905>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.40907>; else goto <D.40908>;
            <D.40907>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40908>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40906>:
            D.40909 = mini_get_debug_options ();
            D.40910 = D.40909->break_on_unverified;
            if (D.40910 != 0) goto <D.40911>; else goto unverified;
            <D.40911>:
            raise (5);
            <D.40904>:
            D.35709 = ip + 6;
            if (D.35709 > end) goto <D.40912>; else goto <D.40913>;
            <D.40912>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.40914>; else goto <D.40915>;
            <D.40914>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.40916>; else goto <D.40917>;
            <D.40916>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40917>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40915>:
            D.40918 = mini_get_debug_options ();
            D.40919 = D.40918->break_on_unverified;
            if (D.40919 != 0) goto <D.40920>; else goto unverified;
            <D.40920>:
            raise (5);
            <D.40913>:
            D.40310 = ip + 2;
            D.40311 = *D.40310;
            n = (int) D.40311;
            n.161 = (unsigned int) n;
            cmethod = mini_get_method (cfg, method, n.161, 0B, generic_context);
            if (cmethod == 0B) goto <D.40921>; else goto <D.40923>;
            <D.40923>:
            D.40924 = mono_loader_get_last_error ();
            if (D.40924 != 0B) goto <D.40921>; else goto <D.40922>;
            <D.40921>:
            D.40925 = mini_get_debug_options ();
            D.40926 = D.40925->break_on_unverified;
            if (D.40926 != 0) goto <D.40927>; else goto load_error;
            <D.40927>:
            raise (5);
            <D.40922>:
            D.32828 = cmethod->klass;
            mono_class_init (D.32828);
            context_used = mini_method_check_context_used (cfg, cmethod);
            D.40928 = mono_security_get_mode ();
            if (D.40928 == 2) goto <D.40929>; else goto <D.40930>;
            <D.40929>:
            D.40931 = check_linkdemand (cfg, method, cmethod);
            if (D.40931 != 0) goto <D.40932>; else goto <D.40933>;
            <D.40932>:
            D.30911 = cfg->method;
            if (D.30911 != method) goto <D.40934>; else goto <D.40935>;
            <D.40934>:
            D.30883 = BIT_FIELD_REF <*method, 64, 256>;
            D.30884 = D.30883 & 124;
            if (D.30884 == 0) goto <D.40936>; else goto <D.40937>;
            <D.40936>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.40938>; else goto <D.40939>;
            <D.40938>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.40939>:
            goto inline_failure;
            <D.40937>:
            <D.40935>:
            <D.40933>:
            D.31510 = cfg->exception_type;
            if (D.31510 != 0) goto exception_exit; else goto <D.40940>;
            <D.40940>:
            goto <D.40941>;
            <D.40930>:
            D.40942 = mono_security_get_mode ();
            if (D.40942 == 1) goto <D.40943>; else goto <D.40944>;
            <D.40943>:
            bblock.70 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.70, ip);
            <D.40944>:
            <D.40941>:
            sp = sp + 18446744073709551608;
            D.31957 = *sp;
            args[0] = D.31957;
            D.40945 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            args[1] = D.40945;
            if (context_used != 0) goto <D.40946>; else goto <D.40947>;
            <D.40946>:
            sp.322 = sp;
            sp = sp.322 + 8;
            D.40949 = mono_emit_jit_icall (cfg, mono_ldvirtfn_gshared, &args);
            *sp.322 = D.40949;
            goto <D.40950>;
            <D.40947>:
            sp.323 = sp;
            sp = sp.323 + 8;
            D.40952 = mono_emit_jit_icall (cfg, mono_ldvirtfn, &args);
            *sp.323 = D.40952;
            <D.40950>:
            ip = ip + 6;
            num_calls.324 = num_calls;
            num_calls = num_calls.324 + 1;
            D.40954 = num_calls.324 * 10;
            inline_costs = D.40954 + inline_costs;
            goto <D.28686>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28706>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.40955>; else goto <D.40956>;
      <D.40955>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40957>; else goto <D.40958>;
      <D.40957>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40959>; else goto <D.40960>;
      <D.40959>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40960>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40958>:
      D.40961 = mini_get_debug_options ();
      D.40962 = D.40961->break_on_unverified;
      if (D.40962 != 0) goto <D.40963>; else goto unverified;
      <D.40963>:
      raise (5);
      <D.40956>:
      D.40964 = ip + 4;
      if (D.40964 > end) goto <D.40965>; else goto <D.40966>;
      <D.40965>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40967>; else goto <D.40968>;
      <D.40967>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40969>; else goto <D.40970>;
      <D.40969>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40970>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40968>:
      D.40971 = mini_get_debug_options ();
      D.40972 = D.40971->break_on_unverified;
      if (D.40972 != 0) goto <D.40973>; else goto unverified;
      <D.40973>:
      raise (5);
      <D.40966>:
      D.40974 = ip + 2;
      D.40975 = *D.40974;
      n = (int) D.40975;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.40976>; else goto <D.40977>;
      <D.40976>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40978>; else goto <D.40979>;
      <D.40978>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.40980>; else goto <D.40981>;
      <D.40980>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40981>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40979>:
      D.40982 = mini_get_debug_options ();
      D.40983 = D.40982->break_on_unverified;
      if (D.40983 != 0) goto <D.40984>; else goto unverified;
      <D.40984>:
      raise (5);
      <D.40977>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.40985 = mono_type_to_regmove (cfg, D.31886);
      D.40986 = (short unsigned int) D.40985;
      ins->opcode = D.40986;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      type_to_eval_stack_type (cfg, D.31886, ins);
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31891 = D.31890->klass;
      ins->klass = D.31891;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31892 = D.31890->dreg;
      ins->sreg1 = D.31892;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.40987 = alloc_dreg (cfg, D.31706);
      D.40988 = (int) D.40987;
      ins->dreg = D.40988;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.40989>; else goto <D.40990>;
      <D.40989>:
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.40991 = mono_class_from_mono_type (D.31886);
      ins->klass = D.40991;
      <D.40990>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.40992>; else goto <D.40993>;
      <D.40992>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.40994>;
      <D.40993>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.40994>:
      sp.325 = sp;
      sp = sp.325 + 8;
      *sp.325 = ins;
      ip = ip + 4;
      goto <D.28686>;
      <D.28707>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.40996>; else goto <D.40997>;
      <D.40996>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.40998>; else goto <D.40999>;
      <D.40998>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 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.40997>:
      D.40964 = ip + 4;
      if (D.40964 > end) goto <D.41005>; else goto <D.41006>;
      <D.41005>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41007>; else goto <D.41008>;
      <D.41007>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41009>; else goto <D.41010>;
      <D.41009>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41010>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41008>:
      D.41011 = mini_get_debug_options ();
      D.41012 = D.41011->break_on_unverified;
      if (D.41012 != 0) goto <D.41013>; else goto unverified;
      <D.41013>:
      raise (5);
      <D.41006>:
      D.40974 = ip + 2;
      D.40975 = *D.40974;
      n = (int) D.40975;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.41014>; else goto <D.41015>;
      <D.41014>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41016>; else goto <D.41017>;
      <D.41016>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41018>; else goto <D.41019>;
      <D.41018>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41019>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41017>:
      D.41020 = mini_get_debug_options ();
      D.41021 = D.41020->break_on_unverified;
      if (D.41021 != 0) goto <D.41022>; else goto unverified;
      <D.41022>:
      raise (5);
      <D.41015>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      ins->data.op[0].p = D.32037;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32038 = D.32037->flags;
      D.32039 = D.32038 | 16;
      D.32037->flags = D.32039;
      ins->type = 5;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32040 = D.32037->klass;
      ins->klass = D.32040;
      D.41023 = alloc_dreg (cfg, 5);
      D.41024 = (int) D.41023;
      ins->dreg = D.41024;
      cfg->has_indirection = 1;
      D.31089 = cfg->gsharedvt;
      D.32043 = D.31089 != 0;
      D.32044 = (long int) D.32043;
      D.32045 = __builtin_expect (D.32044, 0);
      if (D.32045 != 0) goto <D.41025>; else goto <D.41026>;
      <D.41025>:
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.32036 = arg_array + D.31884;
      D.32037 = *D.32036;
      D.32048 = D.32037->data.op[1].vtype;
      D.41027 = mini_is_gsharedvt_variable_type (cfg, D.32048);
      if (D.41027 != 0) goto <D.41028>; else goto <D.41029>;
      <D.41028>:
      handle_gsharedvt_ldaddr (cfg);
      <D.41029>:
      <D.41026>:
      if (0 != 0) goto <D.41030>; else goto <D.41031>;
      <D.41030>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32056 = D.32055 + 1;
        D.32057 = (unsigned int) D.32056;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.32057 < D.32058) goto <D.41033>; else goto <D.41034>;
        <D.41033>:
        D.32061 = cfg->vreg_to_inst;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32062 = (sizetype) D.32055;
        D.32063 = D.32062 + 1;
        D.32064 = D.32063 * 8;
        D.32065 = D.32061 + D.32064;
        iftmp.326 = *D.32065;
        goto <D.41035>;
        <D.41034>:
        iftmp.326 = 0B;
        <D.41035>:
        var1 = iftmp.326;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32068 = D.32055 + 2;
        D.32069 = (unsigned int) D.32068;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.32069 < D.32058) goto <D.41037>; else goto <D.41038>;
        <D.41037>:
        D.32061 = cfg->vreg_to_inst;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.32036 = arg_array + D.31884;
        D.32037 = *D.32036;
        D.32055 = D.32037->dreg;
        D.32062 = (sizetype) D.32055;
        D.32072 = D.32062 + 2;
        D.32073 = D.32072 * 8;
        D.32074 = D.32061 + D.32073;
        iftmp.327 = *D.32074;
        goto <D.41039>;
        <D.41038>:
        iftmp.327 = 0B;
        <D.41039>:
        var2 = iftmp.327;
        D.41040 = var1 == 0B;
        D.41041 = (long int) D.41040;
        D.41042 = __builtin_expect (D.41041, 0);
        if (D.41042 != 0) goto <D.41043>; else goto <D.41044>;
        <D.41043>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11584, "var1");
        <D.41044>:
        D.41045 = var2 == 0B;
        D.41046 = (long int) D.41045;
        D.41047 = __builtin_expect (D.41046, 0);
        if (D.41047 != 0) goto <D.41048>; else goto <D.41049>;
        <D.41048>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11584, "var2");
        <D.41049>:
        D.41050 = var1->flags;
        D.41051 = D.41050 | 16;
        var1->flags = D.41051;
        D.41052 = var2->flags;
        D.41053 = D.41052 | 16;
        var2->flags = D.41053;
      }
      <D.41031>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.41054>; else goto <D.41055>;
      <D.41054>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.41056>;
      <D.41055>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.41056>:
      sp.328 = sp;
      sp = sp.328 + 8;
      *sp.328 = ins;
      ip = ip + 4;
      goto <D.28686>;
      <D.28710>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.41058>; else goto <D.41059>;
      <D.41058>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41060>; else goto <D.41061>;
      <D.41060>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41062>; else goto <D.41063>;
      <D.41062>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41063>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41061>:
      D.41064 = mini_get_debug_options ();
      D.41065 = D.41064->break_on_unverified;
      if (D.41065 != 0) goto <D.41066>; else goto unverified;
      <D.41066>:
      raise (5);
      <D.41059>:
      sp = sp + 18446744073709551608;
      D.40964 = ip + 4;
      if (D.40964 > end) goto <D.41067>; else goto <D.41068>;
      <D.41067>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41069>; else goto <D.41070>;
      <D.41069>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41071>; else goto <D.41072>;
      <D.41071>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41072>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41070>:
      D.41073 = mini_get_debug_options ();
      D.41074 = D.41073->break_on_unverified;
      if (D.41074 != 0) goto <D.41075>; else goto unverified;
      <D.41075>:
      raise (5);
      <D.41068>:
      D.40974 = ip + 2;
      D.40975 = *D.40974;
      n = (int) D.40975;
      n.81 = (unsigned int) n;
      if (n.81 >= num_args) goto <D.41076>; else goto <D.41077>;
      <D.41076>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41078>; else goto <D.41079>;
      <D.41078>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41080>; else goto <D.41081>;
      <D.41080>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41081>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41079>:
      D.41082 = mini_get_debug_options ();
      D.41083 = D.41082->break_on_unverified;
      if (D.41083 != 0) goto <D.41084>; else goto unverified;
      <D.41084>:
      raise (5);
      <D.41077>:
      if (dont_verify_stloc == 0) goto <D.41085>; else goto <D.41086>;
      <D.41085>:
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.41087 = param_types + D.31884;
      D.41088 = *D.41087;
      D.31957 = *sp;
      D.41089 = target_type_is_incompatible (cfg, D.41088, D.31957);
      if (D.41089 != 0) goto <D.41090>; else goto <D.41091>;
      <D.41090>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41092>; else goto <D.41093>;
      <D.41092>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41094>; else goto <D.41095>;
      <D.41094>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41095>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41093>:
      D.41096 = mini_get_debug_options ();
      D.41097 = D.41096->break_on_unverified;
      if (D.41097 != 0) goto <D.41098>; else goto unverified;
      <D.41098>:
      raise (5);
      <D.41091>:
      <D.41086>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.41099 = mono_type_to_regmove (cfg, D.31886);
      D.41100 = (short unsigned int) D.41099;
      ins->opcode = D.41100;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31891 = D.31890->klass;
      ins->klass = D.31891;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      D.31559 = cfg->args;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31889 = D.31559 + D.31884;
      D.31890 = *D.31889;
      D.31892 = D.31890->dreg;
      ins->dreg = D.31892;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.41101>; else goto <D.41102>;
      <D.41101>:
      D.31569 = cfg->arg_types;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31885 = D.31569 + D.31884;
      D.31886 = *D.31885;
      D.41103 = mono_class_from_mono_type (D.31886);
      ins->klass = D.41103;
      <D.41102>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.41104>; else goto <D.41105>;
      <D.41104>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.41106>;
      <D.41105>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.41106>:
      ip = ip + 4;
      goto <D.28686>;
      <D.28711>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      D.31731 = D.31730 /[ex] 8;
      D.31641 = header->max_stack;
      D.31863 = (long int) D.31641;
      if (D.31731 >= D.31863) goto <D.41107>; else goto <D.41108>;
      <D.41107>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41109>; else goto <D.41110>;
      <D.41109>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41111>; else goto <D.41112>;
      <D.41111>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41112>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41110>:
      D.41113 = mini_get_debug_options ();
      D.41114 = D.41113->break_on_unverified;
      if (D.41114 != 0) goto <D.41115>; else goto unverified;
      <D.41115>:
      raise (5);
      <D.41108>:
      D.40964 = ip + 4;
      if (D.40964 > end) goto <D.41116>; else goto <D.41117>;
      <D.41116>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41118>; else goto <D.41119>;
      <D.41118>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41120>; else goto <D.41121>;
      <D.41120>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41121>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41119>:
      D.41122 = mini_get_debug_options ();
      D.41123 = D.41122->break_on_unverified;
      if (D.41123 != 0) goto <D.41124>; else goto unverified;
      <D.41124>:
      raise (5);
      <D.41117>:
      D.40974 = ip + 2;
      D.40975 = *D.40974;
      n = (int) D.40975;
      n.81 = (unsigned int) n;
      D.31546 = header->num_locals;
      D.31911 = (unsigned int) D.31546;
      if (n.81 >= D.31911) goto <D.41125>; else goto <D.41126>;
      <D.41125>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41127>; else goto <D.41128>;
      <D.41127>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41129>; else goto <D.41130>;
      <D.41129>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41130>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41128>:
      D.41131 = mini_get_debug_options ();
      D.41132 = D.41131->break_on_unverified;
      if (D.41132 != 0) goto <D.41133>; else goto unverified;
      <D.41133>:
      raise (5);
      <D.41126>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.31534 = header->locals[n];
      D.41134 = mono_type_to_regmove (cfg, D.31534);
      D.41135 = (short unsigned int) D.41134;
      ins->opcode = D.41135;
      D.31534 = header->locals[n];
      type_to_eval_stack_type (cfg, D.31534, ins);
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31926 = D.31925->klass;
      ins->klass = D.31926;
      D.31923 = cfg->locals;
      D.31883 = (long unsigned int) n;
      D.31884 = D.31883 * 8;
      D.31924 = D.31923 + D.31884;
      D.31925 = *D.31924;
      D.31927 = D.31925->dreg;
      ins->sreg1 = D.31927;
      D.31705 = ins->type;
      D.31706 = (<unnamed type>) D.31705;
      D.41136 = alloc_dreg (cfg, D.31706);
      D.41137 = (int) D.41136;
      ins->dreg = D.41137;
      D.31709 = ins->opcode;
      if (D.31709 == 427) goto <D.41138>; else goto <D.41139>;
      <D.41138>:
      D.31534 = header->locals[n];
      D.41140 = mono_class_from_mono_type (D.31534);
      ins->klass = D.41140;
      <D.41139>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.41141>; else goto <D.41142>;
      <D.41141>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.41143>;
      <D.41142>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.41143>:
      sp.329 = sp;
      sp = sp.329 + 8;
      *sp.329 = ins;
      ip = ip + 4;
      goto <D.28686>;
      <D.28712>:
      {
        unsigned char * tmp_ip;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        D.31731 = D.31730 /[ex] 8;
        D.31641 = header->max_stack;
        D.31863 = (long int) D.31641;
        if (D.31731 >= D.31863) goto <D.41145>; else goto <D.41146>;
        <D.41145>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41147>; else goto <D.41148>;
        <D.41147>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41149>; else goto <D.41150>;
        <D.41149>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41150>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41148>:
        D.41151 = mini_get_debug_options ();
        D.41152 = D.41151->break_on_unverified;
        if (D.41152 != 0) goto <D.41153>; else goto unverified;
        <D.41153>:
        raise (5);
        <D.41146>:
        D.40964 = ip + 4;
        if (D.40964 > end) goto <D.41154>; else goto <D.41155>;
        <D.41154>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41156>; else goto <D.41157>;
        <D.41156>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41158>; else goto <D.41159>;
        <D.41158>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41159>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41157>:
        D.41160 = mini_get_debug_options ();
        D.41161 = D.41160->break_on_unverified;
        if (D.41161 != 0) goto <D.41162>; else goto unverified;
        <D.41162>:
        raise (5);
        <D.41155>:
        D.40974 = ip + 2;
        D.40975 = *D.40974;
        n = (int) D.40975;
        n.81 = (unsigned int) n;
        D.31546 = header->num_locals;
        D.31911 = (unsigned int) D.31546;
        if (n.81 >= D.31911) goto <D.41163>; else goto <D.41164>;
        <D.41163>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41165>; else goto <D.41166>;
        <D.41165>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41167>; else goto <D.41168>;
        <D.41167>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41168>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41166>:
        D.41169 = mini_get_debug_options ();
        D.41170 = D.41169->break_on_unverified;
        if (D.41170 != 0) goto <D.41171>; else goto unverified;
        <D.41171>:
        raise (5);
        <D.41164>:
        tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 2);
        if (tmp_ip != 0B) goto <D.41172>; else goto <D.41173>;
        <D.41172>:
        ip = tmp_ip;
        inline_costs = inline_costs + 1;
        goto <D.28686>;
        <D.41173>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31923 = cfg->locals;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.31924 = D.31923 + D.31884;
        D.31925 = *D.31924;
        ins->data.op[0].p = D.31925;
        D.31923 = cfg->locals;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.31924 = D.31923 + D.31884;
        D.31925 = *D.31924;
        D.31923 = cfg->locals;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.31924 = D.31923 + D.31884;
        D.31925 = *D.31924;
        D.41174 = D.31925->flags;
        D.41175 = D.41174 | 16;
        D.31925->flags = D.41175;
        ins->type = 5;
        D.31923 = cfg->locals;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.31924 = D.31923 + D.31884;
        D.31925 = *D.31924;
        D.31926 = D.31925->klass;
        ins->klass = D.31926;
        D.41176 = alloc_dreg (cfg, 5);
        D.41177 = (int) D.41176;
        ins->dreg = D.41177;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.41178>; else goto <D.41179>;
        <D.41178>:
        D.31923 = cfg->locals;
        D.31883 = (long unsigned int) n;
        D.31884 = D.31883 * 8;
        D.31924 = D.31923 + D.31884;
        D.31925 = *D.31924;
        D.41180 = D.31925->data.op[1].vtype;
        D.41181 = mini_is_gsharedvt_variable_type (cfg, D.41180);
        if (D.41181 != 0) goto <D.41182>; else goto <D.41183>;
        <D.41182>:
        handle_gsharedvt_ldaddr (cfg);
        <D.41183>:
        <D.41179>:
        if (0 != 0) goto <D.41184>; else goto <D.41185>;
        <D.41184>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31923 = cfg->locals;
          D.31883 = (long unsigned int) n;
          D.31884 = D.31883 * 8;
          D.31924 = D.31923 + D.31884;
          D.31925 = *D.31924;
          D.31927 = D.31925->dreg;
          D.41187 = D.31927 + 1;
          D.41188 = (unsigned int) D.41187;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.41188 < D.32058) goto <D.41189>; else goto <D.41190>;
          <D.41189>:
          D.32061 = cfg->vreg_to_inst;
          D.31923 = cfg->locals;
          D.31883 = (long unsigned int) n;
          D.31884 = D.31883 * 8;
          D.31924 = D.31923 + D.31884;
          D.31925 = *D.31924;
          D.31927 = D.31925->dreg;
          D.41191 = (sizetype) D.31927;
          D.41192 = D.41191 + 1;
          D.41193 = D.41192 * 8;
          D.41194 = D.32061 + D.41193;
          iftmp.330 = *D.41194;
          goto <D.41195>;
          <D.41190>:
          iftmp.330 = 0B;
          <D.41195>:
          var1 = iftmp.330;
          D.31923 = cfg->locals;
          D.31883 = (long unsigned int) n;
          D.31884 = D.31883 * 8;
          D.31924 = D.31923 + D.31884;
          D.31925 = *D.31924;
          D.31927 = D.31925->dreg;
          D.41197 = D.31927 + 2;
          D.41198 = (unsigned int) D.41197;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.41198 < D.32058) goto <D.41199>; else goto <D.41200>;
          <D.41199>:
          D.32061 = cfg->vreg_to_inst;
          D.31923 = cfg->locals;
          D.31883 = (long unsigned int) n;
          D.31884 = D.31883 * 8;
          D.31924 = D.31923 + D.31884;
          D.31925 = *D.31924;
          D.31927 = D.31925->dreg;
          D.41191 = (sizetype) D.31927;
          D.41201 = D.41191 + 2;
          D.41202 = D.41201 * 8;
          D.41203 = D.32061 + D.41202;
          iftmp.331 = *D.41203;
          goto <D.41204>;
          <D.41200>:
          iftmp.331 = 0B;
          <D.41204>:
          var2 = iftmp.331;
          D.41205 = var1 == 0B;
          D.41206 = (long int) D.41205;
          D.41207 = __builtin_expect (D.41206, 0);
          if (D.41207 != 0) goto <D.41208>; else goto <D.41209>;
          <D.41208>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11622, "var1");
          <D.41209>:
          D.41210 = var2 == 0B;
          D.41211 = (long int) D.41210;
          D.41212 = __builtin_expect (D.41211, 0);
          if (D.41212 != 0) goto <D.41213>; else goto <D.41214>;
          <D.41213>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11622, "var2");
          <D.41214>:
          D.41215 = var1->flags;
          D.41216 = D.41215 | 16;
          var1->flags = D.41216;
          D.41217 = var2->flags;
          D.41218 = D.41217 | 16;
          var2->flags = D.41218;
        }
        <D.41185>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41219>; else goto <D.41220>;
        <D.41219>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.41221>;
        <D.41220>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41221>:
        sp.332 = sp;
        sp = sp.332 + 8;
        *sp.332 = ins;
        ip = ip + 4;
        goto <D.28686>;
      }
      <D.28716>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.41223>; else goto <D.41224>;
      <D.41223>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41225>; else goto <D.41226>;
      <D.41225>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41227>; else goto <D.41228>;
      <D.41227>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41228>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41226>:
      D.41229 = mini_get_debug_options ();
      D.41230 = D.41229->break_on_unverified;
      if (D.41230 != 0) goto <D.41231>; else goto unverified;
      <D.41231>:
      raise (5);
      <D.41224>:
      sp = sp + 18446744073709551608;
      D.40964 = ip + 4;
      if (D.40964 > end) goto <D.41232>; else goto <D.41233>;
      <D.41232>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41234>; else goto <D.41235>;
      <D.41234>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41236>; else goto <D.41237>;
      <D.41236>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41237>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41235>:
      D.41238 = mini_get_debug_options ();
      D.41239 = D.41238->break_on_unverified;
      if (D.41239 != 0) goto <D.41240>; else goto unverified;
      <D.41240>:
      raise (5);
      <D.41233>:
      D.40974 = ip + 2;
      D.40975 = *D.40974;
      n = (int) D.40975;
      n.81 = (unsigned int) n;
      D.31546 = header->num_locals;
      D.31911 = (unsigned int) D.31546;
      if (n.81 >= D.31911) goto <D.41241>; else goto <D.41242>;
      <D.41241>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41243>; else goto <D.41244>;
      <D.41243>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41245>; else goto <D.41246>;
      <D.41245>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41246>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41244>:
      D.41247 = mini_get_debug_options ();
      D.41248 = D.41247->break_on_unverified;
      if (D.41248 != 0) goto <D.41249>; else goto unverified;
      <D.41249>:
      raise (5);
      <D.41242>:
      if (dont_verify_stloc == 0) goto <D.41250>; else goto <D.41251>;
      <D.41250>:
      D.31534 = header->locals[n];
      D.31957 = *sp;
      D.41252 = target_type_is_incompatible (cfg, D.31534, D.31957);
      if (D.41252 != 0) goto <D.41253>; else goto <D.41254>;
      <D.41253>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41255>; else goto <D.41256>;
      <D.41255>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41257>; else goto <D.41258>;
      <D.41257>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41258>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41256>:
      D.41259 = mini_get_debug_options ();
      D.41260 = D.41259->break_on_unverified;
      if (D.41260 != 0) goto <D.41261>; else goto unverified;
      <D.41261>:
      raise (5);
      <D.41254>:
      <D.41251>:
      emit_stloc_ir (cfg, sp, header, n);
      ip = ip + 4;
      inline_costs = inline_costs + 1;
      goto <D.28686>;
      <D.28717>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.41262>; else goto <D.41263>;
      <D.41262>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41264>; else goto <D.41265>;
      <D.41264>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41266>; else goto <D.41267>;
      <D.41266>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41267>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41265>:
      D.41268 = mini_get_debug_options ();
      D.41269 = D.41268->break_on_unverified;
      if (D.41269 != 0) goto <D.41270>; else goto unverified;
      <D.41270>:
      raise (5);
      <D.41263>:
      sp = sp + 18446744073709551608;
      if (sp != stack_start) goto <D.41271>; else goto <D.41272>;
      <D.41271>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41273>; else goto <D.41274>;
      <D.41273>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41275>; else goto <D.41276>;
      <D.41275>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41276>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41274>:
      D.41277 = mini_get_debug_options ();
      D.41278 = D.41277->break_on_unverified;
      if (D.41278 != 0) goto <D.41279>; else goto unverified;
      <D.41279>:
      raise (5);
      <D.41272>:
      D.30911 = cfg->method;
      if (D.30911 != method) goto inline_failure; else goto <D.41280>;
      <D.41280>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 338;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      D.41281 = alloc_preg (cfg);
      D.41282 = (int) D.41281;
      ins->dreg = D.41282;
      D.31957 = *sp;
      D.32139 = D.31957->dreg;
      ins->sreg1 = D.32139;
      ins->type = 3;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      if (D.31191 != 0B) goto <D.41283>; else goto <D.41284>;
      <D.41283>:
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      D.31191->next = ins;
      bblock.113 = cfg->cbb;
      D.31191 = bblock.113->last_ins;
      ins->prev = D.31191;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      goto <D.41285>;
      <D.41284>:
      bblock.113 = cfg->cbb;
      bblock.113 = cfg->cbb;
      bblock.113->last_ins = ins;
      D.31191 = bblock.113->last_ins;
      bblock.113->code = D.31191;
      <D.41285>:
      D.31372 = cfg->flags;
      D.31373 = D.31372 | 1;
      cfg->flags = D.31373;
      if (init_locals != 0) goto <D.41286>; else goto <D.41287>;
      <D.41286>:
      D.31805 = ins->flags;
      D.41288 = D.31805 | 1;
      ins->flags = D.41288;
      <D.41287>:
      sp.333 = sp;
      sp = sp.333 + 8;
      *sp.333 = ins;
      ip = ip + 2;
      goto <D.28686>;
      <D.28718>:
      {
        struct MonoExceptionClause * clause;
        struct MonoExceptionClause * nearest;
        int cc;
        int nearest_num;

        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.41290>; else goto <D.41291>;
        <D.41290>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41292>; else goto <D.41293>;
        <D.41292>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41294>; else goto <D.41295>;
        <D.41294>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41295>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41293>:
        D.41296 = mini_get_debug_options ();
        D.41297 = D.41296->break_on_unverified;
        if (D.41297 != 0) goto <D.41298>; else goto unverified;
        <D.41298>:
        raise (5);
        <D.41291>:
        sp = sp + 18446744073709551608;
        if (sp != stack_start) goto <D.41299>; else goto <D.41301>;
        <D.41301>:
        D.31957 = *sp;
        D.33688 = D.31957->type;
        if (D.33688 != 1) goto <D.41299>; else goto <D.41300>;
        <D.41299>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41302>; else goto <D.41303>;
        <D.41302>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41304>; else goto <D.41305>;
        <D.41304>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41305>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41303>:
        D.41306 = mini_get_debug_options ();
        D.41307 = D.41306->break_on_unverified;
        if (D.41307 != 0) goto <D.41308>; else goto unverified;
        <D.41308>:
        raise (5);
        <D.41300>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 737;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        ins->sreg1 = D.32139;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.41309>; else goto <D.41310>;
        <D.41309>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.41311>;
        <D.41310>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.41311>:
        start_new_bblock = 1;
        ip = ip + 2;
        nearest = 0B;
        nearest_num = 0;
        cc = 0;
        goto <D.28724>;
        <D.28723>:
        D.31068 = header->clauses;
        D.41312 = (long unsigned int) cc;
        D.41313 = D.41312 * 32;
        clause = D.31068 + D.41313;
        D.41316 = clause->flags;
        D.41317 = D.41316 & 1;
        if (D.41317 != 0) goto <D.41318>; else goto <D.41319>;
        <D.41318>:
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        D.41320 = clause->data.filter_offset;
        D.41321 = (long int) D.41320;
        if (D.31651 > D.41321) goto <D.41322>; else goto <D.41323>;
        <D.41322>:
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        D.41324 = clause->handler_offset;
        D.41325 = (long int) D.41324;
        if (D.31651 <= D.41325) goto <D.41326>; else goto <D.41327>;
        <D.41326>:
        if (nearest == 0B) goto <D.41314>; else goto <D.41328>;
        <D.41328>:
        D.41320 = clause->data.filter_offset;
        D.41329 = nearest->data.filter_offset;
        if (D.41320 < D.41329) goto <D.41314>; else goto <D.41315>;
        <D.41314>:
        nearest = clause;
        nearest_num = cc;
        <D.41315>:
        <D.41327>:
        <D.41323>:
        <D.41319>:
        cc = cc + 1;
        <D.28724>:
        D.31257 = header->num_clauses;
        D.31258 = (int) D.31257;
        if (D.31258 > cc) goto <D.28723>; else goto <D.28725>;
        <D.28725>:
        D.41330 = nearest == 0B;
        D.41331 = (long int) D.41330;
        D.41332 = __builtin_expect (D.41331, 0);
        if (D.41332 != 0) goto <D.41333>; else goto <D.41334>;
        <D.41333>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11690, "nearest");
        <D.41334>:
        ip.75 = (long int) ip;
        D.31088 = header->code;
        D.31650 = (long int) D.31088;
        D.31651 = ip.75 - D.31650;
        D.41335 = nearest->handler_offset;
        D.41336 = (long int) D.41335;
        if (D.31651 != D.41336) goto <D.41337>; else goto <D.41338>;
        <D.41337>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41339>; else goto <D.41340>;
        <D.41339>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41341>; else goto <D.41342>;
        <D.41341>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41342>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41340>:
        D.41343 = mini_get_debug_options ();
        D.41344 = D.41343->break_on_unverified;
        if (D.41344 != 0) goto <D.41345>; else goto unverified;
        <D.41345>:
        raise (5);
        <D.41338>:
        goto <D.28686>;
      }
      <D.28726>:
      ins_flag = ins_flag | 8;
      D.41346 = ip + 3;
      if (D.41346 > end) goto <D.41347>; else goto <D.41348>;
      <D.41347>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41349>; else goto <D.41350>;
      <D.41349>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41351>; else goto <D.41352>;
      <D.41351>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41352>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41350>:
      D.41353 = mini_get_debug_options ();
      D.41354 = D.41353->break_on_unverified;
      if (D.41354 != 0) goto <D.41355>; else goto unverified;
      <D.41355>:
      raise (5);
      <D.41348>:
      ip = ip + 3;
      goto <D.28686>;
      <D.28727>:
      ins_flag = ins_flag | 4;
      ip = ip + 2;
      goto <D.28686>;
      <D.28728>:
      ins_flag = ins_flag | 4;
      D.31372 = cfg->flags;
      D.41356 = D.31372 | 16;
      cfg->flags = D.41356;
      inline_costs = inline_costs + 100000;
      ip = ip + 2;
      goto <D.28686>;
      <D.28729>:
      sp.77 = (long int) sp;
      stack_start.78 = (long int) stack_start;
      D.31730 = sp.77 - stack_start.78;
      if (D.31730 <= 7) goto <D.41357>; else goto <D.41358>;
      <D.41357>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41359>; else goto <D.41360>;
      <D.41359>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41361>; else goto <D.41362>;
      <D.41361>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41362>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41360>:
      D.41363 = mini_get_debug_options ();
      D.41364 = D.41363->break_on_unverified;
      if (D.41364 != 0) goto <D.41365>; else goto unverified;
      <D.41365>:
      raise (5);
      <D.41358>:
      sp = sp + 18446744073709551608;
      D.35709 = ip + 6;
      if (D.35709 > end) goto <D.41366>; else goto <D.41367>;
      <D.41366>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41368>; else goto <D.41369>;
      <D.41368>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41370>; else goto <D.41371>;
      <D.41370>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41371>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41369>:
      D.41372 = mini_get_debug_options ();
      D.41373 = D.41372->break_on_unverified;
      if (D.41373 != 0) goto <D.41374>; else goto unverified;
      <D.41374>:
      raise (5);
      <D.41367>:
      token = MEM[(const guint32 *)ip + 2B];
      klass.334 = mini_get_class (method, token, generic_context);
      klass = klass.334;
      klass.157 = klass;
      if (klass.157 == 0B) goto <D.41376>; else goto <D.41378>;
      <D.41378>:
      klass.157 = klass;
      D.35652 = klass.157->exception_type;
      if (D.35652 != 0) goto <D.41376>; else goto <D.41377>;
      <D.41376>:
      klass.157 = klass;
      cfg->exception_ptr = klass.157;
      D.41379 = mini_get_debug_options ();
      D.41380 = D.41379->break_on_unverified;
      if (D.41380 != 0) goto <D.41381>; else goto load_error;
      <D.41381>:
      raise (5);
      <D.41377>:
      klass.157 = klass;
      D.41382 = generic_class_is_reference_type (cfg, klass.157);
      if (D.41382 != 0) goto <D.41383>; else goto <D.41384>;
      <D.41383>:
      {
        struct MonoInst * inst;

        D.30941 = cfg->mempool;
        inst = mono_mempool_alloc (D.30941, 80);
        inst->data.op[1].const_val = 0;
        D.41385 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41385;
        inst->prev = 0B;
        D.41386 = inst->prev;
        inst->next = D.41386;
        inst->opcode = 381;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41387 = inst->sreg3;
        inst->sreg2 = D.41387;
        D.41388 = inst->sreg2;
        inst->sreg1 = D.41388;
        D.31162 = cfg->ip;
        inst->cil_code = D.31162;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        inst->dreg = D.32139;
        inst->data.op[0].const_val = 0;
        inst->data.op[1].const_val = 0;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41389>; else goto <D.41390>;
        <D.41389>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = inst;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        inst->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = inst;
        goto <D.41391>;
        <D.41390>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = inst;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41391>:
      }
      goto <D.41392>;
      <D.41384>:
      D.31957 = *sp;
      klass.157 = klass;
      mini_emit_initobj (cfg, D.31957, 0B, klass.157);
      <D.41392>:
      ip = ip + 6;
      inline_costs = inline_costs + 1;
      goto <D.28686>;
      <D.28731>:
      D.35709 = ip + 6;
      if (D.35709 > end) goto <D.41393>; else goto <D.41394>;
      <D.41393>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41395>; else goto <D.41396>;
      <D.41395>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41397>; else goto <D.41398>;
      <D.41397>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41398>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41396>:
      D.41399 = mini_get_debug_options ();
      D.41400 = D.41399->break_on_unverified;
      if (D.41400 != 0) goto <D.41401>; else goto unverified;
      <D.41401>:
      raise (5);
      <D.41394>:
      token = MEM[(const guint32 *)ip + 2B];
      constrained_call = mini_get_class (method, token, generic_context);
      if (constrained_call == 0B) goto <D.41402>; else goto <D.41404>;
      <D.41404>:
      D.33252 = constrained_call->exception_type;
      if (D.33252 != 0) goto <D.41402>; else goto <D.41403>;
      <D.41402>:
      cfg->exception_ptr = constrained_call;
      D.41405 = mini_get_debug_options ();
      D.41406 = D.41405->break_on_unverified;
      if (D.41406 != 0) goto <D.41407>; else goto load_error;
      <D.41407>:
      raise (5);
      <D.41403>:
      ip = ip + 6;
      goto <D.28686>;
      <D.28732>:
      <D.28733>:
      {
        struct MonoInst * iargs[3];

        try
          {
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            if (D.31730 <= 23) goto <D.41408>; else goto <D.41409>;
            <D.41408>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.41410>; else goto <D.41411>;
            <D.41410>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.41412>; else goto <D.41413>;
            <D.41412>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.41413>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.41411>:
            D.41414 = mini_get_debug_options ();
            D.41415 = D.41414->break_on_unverified;
            if (D.41415 != 0) goto <D.41416>; else goto unverified;
            <D.41416>:
            raise (5);
            <D.41409>:
            sp = sp + 18446744073709551592;
            D.31987 = ip + 1;
            D.31988 = *D.31987;
            if (D.31988 == 23) goto <D.41419>; else goto <D.41417>;
            <D.41419>:
            D.31334 = cfg->opt;
            D.33349 = D.31334 & 2048;
            if (D.33349 != 0) goto <D.41420>; else goto <D.41417>;
            <D.41420>:
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41423 = D.41422->opcode;
            if (D.41423 == 362) goto <D.41424>; else goto <D.41417>;
            <D.41424>:
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41425 = D.41422->data.op[0].const_val;
            n = (int) D.41425;
            n.81 = (unsigned int) n;
            if (n.81 <= 40) goto <D.41426>; else goto <D.41417>;
            <D.41426>:
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            D.33091 = D.33090->dreg;
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41425 = D.41422->data.op[0].const_val;
            D.41427 = (int) D.41425;
            mini_emit_memcpy (cfg, D.32139, 0, D.33091, 0, D.41427, 0);
            goto <D.41418>;
            <D.41417>:
            D.31987 = ip + 1;
            D.31988 = *D.31987;
            if (D.31988 == 24) goto <D.41430>; else goto <D.41428>;
            <D.41430>:
            D.31334 = cfg->opt;
            D.33349 = D.31334 & 2048;
            if (D.33349 != 0) goto <D.41431>; else goto <D.41428>;
            <D.41431>:
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41423 = D.41422->opcode;
            if (D.41423 == 362) goto <D.41432>; else goto <D.41428>;
            <D.41432>:
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41425 = D.41422->data.op[0].const_val;
            n = (int) D.41425;
            n.81 = (unsigned int) n;
            if (n.81 <= 40) goto <D.41433>; else goto <D.41428>;
            <D.41433>:
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            D.35301 = D.33090->opcode;
            if (D.35301 == 362) goto <D.41434>; else goto <D.41428>;
            <D.41434>:
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            D.35326 = D.33090->data.op[0].const_val;
            if (D.35326 == 0) goto <D.41435>; else goto <D.41428>;
            <D.41435>:
            D.31957 = *sp;
            D.32139 = D.31957->dreg;
            D.41421 = sp + 16;
            D.41422 = *D.41421;
            D.41425 = D.41422->data.op[0].const_val;
            D.41427 = (int) D.41425;
            D.33089 = sp + 8;
            D.33090 = *D.33089;
            D.35326 = D.33090->data.op[0].const_val;
            D.41436 = (int) D.35326;
            mini_emit_memset (cfg, D.32139, 0, D.41427, D.41436, 0);
            goto <D.41429>;
            <D.41428>:
            D.31957 = *sp;
            iargs[0] = D.31957;
            D.36145 = MEM[(struct MonoInst * *)sp + 8B];
            iargs[1] = D.36145;
            D.41437 = MEM[(struct MonoInst * *)sp + 16B];
            iargs[2] = D.41437;
            D.31987 = ip + 1;
            D.31988 = *D.31987;
            if (D.31988 == 23) goto <D.41438>; else goto <D.41439>;
            <D.41438>:
            {
              struct MonoMethod * memcpy_method;

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

              memset_method = get_memset_method ();
              mono_emit_method_call (cfg, memset_method, &iargs, 0B);
            }
            <D.41440>:
            <D.41429>:
            <D.41418>:
            ip = ip + 2;
            inline_costs = inline_costs + 1;
            goto <D.28686>;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.28737>:
      D.41346 = ip + 3;
      if (D.41346 > end) goto <D.41441>; else goto <D.41442>;
      <D.41441>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41443>; else goto <D.41444>;
      <D.41443>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41445>; else goto <D.41446>;
      <D.41445>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41446>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41444>:
      D.41447 = mini_get_debug_options ();
      D.41448 = D.41447->break_on_unverified;
      if (D.41448 != 0) goto <D.41449>; else goto unverified;
      <D.41449>:
      raise (5);
      <D.41442>:
      D.31968 = ip + 2;
      D.41450 = *D.31968;
      D.41451 = (int) D.41450;
      D.41452 = D.41451 & 1;
      if (D.41452 != 0) goto <D.41453>; else goto <D.41454>;
      <D.41453>:
      ins_flag = ins_flag | 4;
      <D.41454>:
      D.31968 = ip + 2;
      D.41450 = *D.31968;
      D.41451 = (int) D.41450;
      D.41455 = D.41451 & 2;
      if (D.41455 != 0) goto <D.41456>; else goto <D.41457>;
      <D.41456>:
      ins_flag = ins_flag | 16;
      <D.41457>:
      ip = ip + 3;
      goto <D.28686>;
      <D.28738>:
      {
        struct MonoInst * load;
        int handler_offset;

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

          D.31068 = header->clauses;
          D.31069 = (long unsigned int) i;
          D.31070 = D.31069 * 32;
          clause = D.31068 + D.31070;
          D.41458 = clause->handler_offset;
          D.41459 = (long int) D.41458;
          ip.75 = (long int) ip;
          D.31088 = header->code;
          D.31650 = (long int) D.31088;
          D.31651 = ip.75 - D.31650;
          if (D.41459 <= D.31651) goto <D.41460>; else goto <D.41461>;
          <D.41460>:
          ip.75 = (long int) ip;
          D.31088 = header->code;
          D.31650 = (long int) D.31088;
          D.31651 = ip.75 - D.31650;
          D.41458 = clause->handler_offset;
          D.41462 = clause->handler_len;
          D.41463 = D.41458 + D.41462;
          D.41464 = (long int) D.41463;
          if (D.31651 < D.41464) goto <D.41465>; else goto <D.41466>;
          <D.41465>:
          D.41467 = clause->flags;
          D.41468 = D.41467 & 2;
          if (D.41468 == 0) goto <D.41469>; else goto <D.41470>;
          <D.41469>:
          D.41458 = clause->handler_offset;
          handler_offset = (int) D.41458;
          goto <D.28742>;
          <D.41470>:
          <D.41466>:
          <D.41461>:
        }
        i = i + 1;
        <D.28744>:
        D.31257 = header->num_clauses;
        D.31258 = (int) D.31257;
        if (D.31258 > i) goto <D.28743>; else goto <D.28742>;
        <D.28742>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        D.41471 = bblock.70->flags;
        D.41472 = D.41471 | 8;
        bblock.70->flags = D.41472;
        D.41473 = handler_offset == -1;
        D.41474 = (long int) D.41473;
        D.41475 = __builtin_expect (D.41474, 0);
        if (D.41475 != 0) goto <D.41476>; else goto <D.41477>;
        <D.41476>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11786, "handler_offset != -1");
        <D.41477>:
        D.30941 = cfg->mempool;
        load = mono_mempool_alloc (D.30941, 80);
        load->data.op[1].const_val = 0;
        D.41478 = load->data.op[1].const_val;
        load->data.op[0].const_val = D.41478;
        load->prev = 0B;
        D.41479 = load->prev;
        load->next = D.41479;
        load->opcode = 424;
        load->flags = 0;
        load->type = 0;
        load->dreg = -1;
        load->sreg3 = -1;
        D.41480 = load->sreg3;
        load->sreg2 = D.41480;
        D.41481 = load->sreg2;
        load->sreg1 = D.41481;
        D.31162 = cfg->ip;
        load->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.41482 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.41483 = D.41482->data.op[0].const_val;
        D.41484 = (long unsigned int) D.41483;
        D.41485 = D.41484 * 8;
        D.41486 = D.31695 + D.41485;
        D.41487 = *D.41486;
        D.41488 = D.41487->data.op[1].vtype;
        D.41489 = mono_type_to_regmove (cfg, D.41488);
        D.41490 = (short unsigned int) D.41489;
        load->opcode = D.41490;
        D.31695 = cfg->varinfo;
        D.41491 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.41492 = D.41491->data.op[0].const_val;
        D.41493 = (long unsigned int) D.41492;
        D.41494 = D.41493 * 8;
        D.41495 = D.31695 + D.41494;
        D.41496 = *D.41495;
        D.41497 = D.41496->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.41497, load);
        D.31695 = cfg->varinfo;
        D.41498 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.41499 = D.41498->data.op[0].const_val;
        D.41500 = (long unsigned int) D.41499;
        D.41501 = D.41500 * 8;
        D.41502 = D.31695 + D.41501;
        D.41503 = *D.41502;
        D.41504 = D.41503->klass;
        load->klass = D.41504;
        D.31695 = cfg->varinfo;
        D.41505 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.41506 = D.41505->data.op[0].const_val;
        D.41507 = (long unsigned int) D.41506;
        D.41508 = D.41507 * 8;
        D.41509 = D.31695 + D.41508;
        D.41510 = *D.41509;
        D.41511 = D.41510->dreg;
        load->sreg1 = D.41511;
        D.41512 = load->type;
        D.41513 = (<unnamed type>) D.41512;
        D.41514 = alloc_dreg (cfg, D.41513);
        D.41515 = (int) D.41514;
        load->dreg = D.41515;
        D.41516 = load->opcode;
        if (D.41516 == 427) goto <D.41517>; else goto <D.41518>;
        <D.41517>:
        D.31695 = cfg->varinfo;
        D.41519 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.41520 = D.41519->data.op[0].const_val;
        D.41521 = (long unsigned int) D.41520;
        D.41522 = D.41521 * 8;
        D.41523 = D.31695 + D.41522;
        D.41524 = *D.41523;
        D.41525 = D.41524->data.op[1].vtype;
        D.41526 = mono_class_from_mono_type (D.41525);
        load->klass = D.41526;
        <D.41518>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41527>; else goto <D.41528>;
        <D.41527>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = load;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        load->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = load;
        goto <D.41529>;
        <D.41528>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = load;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41529>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 372;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.41530 = load->dreg;
        ins->sreg1 = D.41530;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.41531>; else goto <D.41532>;
        <D.41531>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.41533>;
        <D.41532>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.41533>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        ins->opcode = 798;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        if (D.31279 != 0B) goto <D.41534>; else goto <D.41535>;
        <D.41534>:
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        D.31279->next = ins;
        bblock.70 = bblock;
        D.31279 = bblock.70->last_ins;
        ins->prev = D.31279;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        goto <D.41536>;
        <D.41535>:
        bblock.70 = bblock;
        bblock.70 = bblock;
        bblock.70->last_ins = ins;
        D.31279 = bblock.70->last_ins;
        bblock.70->code = D.31279;
        <D.41536>:
        sp = stack_start;
        bblock.70 = bblock;
        link_bblock (cfg, bblock.70, end_bblock);
        start_new_bblock = 1;
        ip = ip + 2;
        goto <D.28686>;
      }
      <D.28745>:
      {
        guint32 val;
        int ialign;

        try
          {
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.41537>; else goto <D.41538>;
            <D.41537>:
            D.30878 = method->klass;
            D.32629 = D.30878->name_space;
            D.30878 = method->klass;
            D.32630 = D.30878->name;
            D.32631 = method->name;
            D.32632 = method->signature;
            D.32633 = D.32632->param_count;
            D.32634 = (int) D.32633;
            D.31838 = *ip;
            D.31839 = (int) D.31838;
            D.41539 = mono_opcode_name (D.31839);
            D.41540 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.41539, "method-to-ir.c", 11806);
            cfg->exception_message = D.41540;
            D.31021 = cfg->verbose_level;
            if (D.31021 > 1) goto <D.41541>; else goto <D.41542>;
            <D.41541>:
            D.32639 = cfg->exception_message;
            printf ("%s\n", D.32639);
            <D.41542>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.41538>:
            sp.77 = (long int) sp;
            stack_start.78 = (long int) stack_start;
            D.31730 = sp.77 - stack_start.78;
            D.31731 = D.31730 /[ex] 8;
            D.31641 = header->max_stack;
            D.31863 = (long int) D.31641;
            if (D.31731 >= D.31863) goto <D.41543>; else goto <D.41544>;
            <D.41543>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.41545>; else goto <D.41546>;
            <D.41545>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.41547>; else goto <D.41548>;
            <D.41547>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.41548>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.41546>:
            D.41549 = mini_get_debug_options ();
            D.41550 = D.41549->break_on_unverified;
            if (D.41550 != 0) goto <D.41551>; else goto unverified;
            <D.41551>:
            raise (5);
            <D.41544>:
            D.35709 = ip + 6;
            if (D.35709 > end) goto <D.41552>; else goto <D.41553>;
            <D.41552>:
            D.31089 = cfg->gsharedvt;
            if (D.31089 != 0) goto <D.41554>; else goto <D.41555>;
            <D.41554>:
            D.31021 = cfg->verbose_level;
            if (D.31021 > 2) goto <D.41556>; else goto <D.41557>;
            <D.41556>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.41557>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.41555>:
            D.41558 = mini_get_debug_options ();
            D.41559 = D.41558->break_on_unverified;
            if (D.41559 != 0) goto <D.41560>; else goto unverified;
            <D.41560>:
            raise (5);
            <D.41553>:
            token = MEM[(const guint32 *)ip + 2B];
            D.41563 = token >> 24;
            if (D.41563 == 27) goto <D.41564>; else goto <D.41561>;
            <D.41564>:
            D.30878 = method->klass;
            D.30879 = D.30878->image;
            D.41565 = BIT_FIELD_REF <*D.30879, 64, 192>;
            D.41566 = D.41565 & 34359738368;
            if (D.41566 == 0) goto <D.41567>; else goto <D.41561>;
            <D.41567>:
            if (generic_context == 0B) goto <D.41568>; else goto <D.41561>;
            <D.41568>:
            {
              struct MonoType * type;

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

              klass = mono_class_get_full (image, token, generic_context);
              if (klass == 0B) goto <D.41570>; else goto <D.41572>;
              <D.41572>:
              D.41573 = klass->exception_type;
              if (D.41573 != 0) goto <D.41570>; else goto <D.41571>;
              <D.41570>:
              cfg->exception_ptr = klass;
              D.41574 = mini_get_debug_options ();
              D.41575 = D.41574->break_on_unverified;
              if (D.41575 != 0) goto <D.41576>; else goto load_error;
              <D.41576>:
              raise (5);
              <D.41571>:
              mono_class_init (klass);
              D.41577 = &klass->byval_arg;
              D.41578 = mono_type_size (D.41577, &ialign);
              val = (guint32) D.41578;
            }
            <D.41562>:
            D.30941 = cfg->mempool;
            ins = mono_mempool_alloc (D.30941, 80);
            ins->data.op[1].const_val = 0;
            D.31158 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.31158;
            ins->prev = 0B;
            D.31159 = ins->prev;
            ins->next = D.31159;
            ins->opcode = 362;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.31160 = ins->sreg3;
            ins->sreg2 = D.31160;
            D.31161 = ins->sreg2;
            ins->sreg1 = D.31161;
            D.31162 = cfg->ip;
            ins->cil_code = D.31162;
            D.41579 = (long int) val;
            ins->data.op[0].const_val = D.41579;
            ins->type = 1;
            D.41580 = alloc_dreg (cfg, 1);
            D.41581 = (int) D.41580;
            ins->dreg = D.41581;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            if (D.31191 != 0B) goto <D.41582>; else goto <D.41583>;
            <D.41582>:
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            D.31191->next = ins;
            bblock.113 = cfg->cbb;
            D.31191 = bblock.113->last_ins;
            ins->prev = D.31191;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            goto <D.41584>;
            <D.41583>:
            bblock.113 = cfg->cbb;
            bblock.113 = cfg->cbb;
            bblock.113->last_ins = ins;
            D.31191 = bblock.113->last_ins;
            bblock.113->code = D.31191;
            <D.41584>:
            sp.335 = sp;
            sp = sp.335 + 8;
            *sp.335 = ins;
            ip = ip + 6;
            goto <D.28686>;
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.28750>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;

        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41586>; else goto <D.41587>;
        <D.41586>:
        D.30878 = method->klass;
        D.32629 = D.30878->name_space;
        D.30878 = method->klass;
        D.32630 = D.30878->name;
        D.32631 = method->name;
        D.32632 = method->signature;
        D.32633 = D.32632->param_count;
        D.32634 = (int) D.32633;
        D.31838 = *ip;
        D.31839 = (int) D.31838;
        D.41588 = mono_opcode_name (D.31839);
        D.41589 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.32629, D.32630, D.32631, D.32634, D.41588, "method-to-ir.c", 11828);
        cfg->exception_message = D.41589;
        D.31021 = cfg->verbose_level;
        if (D.31021 > 1) goto <D.41590>; else goto <D.41591>;
        <D.41590>:
        D.32639 = cfg->exception_message;
        printf ("%s\n", D.32639);
        <D.41591>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41587>:
        sp.77 = (long int) sp;
        stack_start.78 = (long int) stack_start;
        D.31730 = sp.77 - stack_start.78;
        if (D.31730 <= 7) goto <D.41592>; else goto <D.41593>;
        <D.41592>:
        D.31089 = cfg->gsharedvt;
        if (D.31089 != 0) goto <D.41594>; else goto <D.41595>;
        <D.41594>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41596>; else goto <D.41597>;
        <D.41596>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41597>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41595>:
        D.41598 = mini_get_debug_options ();
        D.41599 = D.41598->break_on_unverified;
        if (D.41599 != 0) goto <D.41600>; else goto unverified;
        <D.41600>:
        raise (5);
        <D.41593>:
        sp = sp + 18446744073709551608;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37427 = (unsigned int) D.32139;
        D.32058 = cfg->vreg_to_inst_len;
        if (D.37427 < D.32058) goto <D.41602>; else goto <D.41603>;
        <D.41602>:
        D.32061 = cfg->vreg_to_inst;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        D.37430 = (long unsigned int) D.32139;
        D.37431 = D.37430 * 8;
        D.37432 = D.32061 + D.37431;
        iftmp.336 = *D.37432;
        goto <D.41604>;
        <D.41603>:
        iftmp.336 = 0B;
        <D.41604>:
        src_var = iftmp.336;
        if (src_var == 0B) goto <D.41605>; else goto <D.41606>;
        <D.41605>:
        D.38817 = mono_defaults.typed_reference_class;
        D.38818 = &D.38817->byval_arg;
        D.31957 = *sp;
        D.32139 = D.31957->dreg;
        src_var = mono_compile_create_var_for_vreg (cfg, D.38818, 329, D.32139);
        <D.41606>:
        D.30941 = cfg->mempool;
        src = mono_mempool_alloc (D.30941, 80);
        src->data.op[1].const_val = 0;
        D.41607 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.41607;
        src->prev = 0B;
        D.41608 = src->prev;
        src->next = D.41608;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.41609 = src->sreg3;
        src->sreg2 = D.41609;
        D.41610 = src->sreg2;
        src->sreg1 = D.41610;
        D.31162 = cfg->ip;
        src->cil_code = D.31162;
        src->data.op[0].p = src_var;
        D.41611 = src_var->flags;
        D.41612 = D.41611 | 16;
        src_var->flags = D.41612;
        src->type = 5;
        D.41613 = src_var->klass;
        src->klass = D.41613;
        D.41614 = alloc_dreg (cfg, 5);
        D.41615 = (int) D.41614;
        src->dreg = D.41615;
        cfg->has_indirection = 1;
        D.31089 = cfg->gsharedvt;
        D.32043 = D.31089 != 0;
        D.32044 = (long int) D.32043;
        D.32045 = __builtin_expect (D.32044, 0);
        if (D.32045 != 0) goto <D.41616>; else goto <D.41617>;
        <D.41616>:
        D.41618 = src_var->data.op[1].vtype;
        D.41619 = mini_is_gsharedvt_variable_type (cfg, D.41618);
        if (D.41619 != 0) goto <D.41620>; else goto <D.41621>;
        <D.41620>:
        handle_gsharedvt_ldaddr (cfg);
        <D.41621>:
        <D.41617>:
        if (0 != 0) goto <D.41622>; else goto <D.41623>;
        <D.41622>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.41625 = src_var->dreg;
          D.41626 = D.41625 + 1;
          D.41627 = (unsigned int) D.41626;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.41627 < D.32058) goto <D.41628>; else goto <D.41629>;
          <D.41628>:
          D.32061 = cfg->vreg_to_inst;
          D.41625 = src_var->dreg;
          D.41630 = (sizetype) D.41625;
          D.41631 = D.41630 + 1;
          D.41632 = D.41631 * 8;
          D.41633 = D.32061 + D.41632;
          iftmp.337 = *D.41633;
          goto <D.41634>;
          <D.41629>:
          iftmp.337 = 0B;
          <D.41634>:
          var1 = iftmp.337;
          D.41625 = src_var->dreg;
          D.41636 = D.41625 + 2;
          D.41637 = (unsigned int) D.41636;
          D.32058 = cfg->vreg_to_inst_len;
          if (D.41637 < D.32058) goto <D.41638>; else goto <D.41639>;
          <D.41638>:
          D.32061 = cfg->vreg_to_inst;
          D.41625 = src_var->dreg;
          D.41630 = (sizetype) D.41625;
          D.41640 = D.41630 + 2;
          D.41641 = D.41640 * 8;
          D.41642 = D.32061 + D.41641;
          iftmp.338 = *D.41642;
          goto <D.41643>;
          <D.41639>:
          iftmp.338 = 0B;
          <D.41643>:
          var2 = iftmp.338;
          D.41644 = var1 == 0B;
          D.41645 = (long int) D.41644;
          D.41646 = __builtin_expect (D.41645, 0);
          if (D.41646 != 0) goto <D.41647>; else goto <D.41648>;
          <D.41647>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11837, "var1");
          <D.41648>:
          D.41649 = var2 == 0B;
          D.41650 = (long int) D.41649;
          D.41651 = __builtin_expect (D.41650, 0);
          if (D.41651 != 0) goto <D.41652>; else goto <D.41653>;
          <D.41652>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11837, "var2");
          <D.41653>:
          D.41654 = var1->flags;
          D.41655 = D.41654 | 16;
          var1->flags = D.41655;
          D.41656 = var2->flags;
          D.41657 = D.41656 | 16;
          var2->flags = D.41657;
        }
        <D.41623>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41658>; else goto <D.41659>;
        <D.41658>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = src;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        src->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        goto <D.41660>;
        <D.41659>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = src;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41660>:
        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.31158 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.31158;
        ins->prev = 0B;
        D.31159 = ins->prev;
        ins->next = D.31159;
        D.39126 = mono_defaults.typehandle_class;
        D.41661 = &D.39126->byval_arg;
        D.41662 = mono_type_to_load_membase (cfg, D.41661);
        D.41663 = (short unsigned int) D.41662;
        ins->opcode = D.41663;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.31160 = ins->sreg3;
        ins->sreg2 = D.31160;
        D.31161 = ins->sreg2;
        ins->sreg1 = D.31161;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        ins->dreg = 0;
        D.41664 = src->dreg;
        ins->sreg1 = D.41664;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        D.39126 = mono_defaults.typehandle_class;
        D.41661 = &D.39126->byval_arg;
        type_to_eval_stack_type (cfg, D.41661, ins);
        D.31705 = ins->type;
        D.31706 = (<unnamed type>) D.31705;
        D.41665 = alloc_dreg (cfg, D.31706);
        D.41666 = (int) D.41665;
        ins->dreg = D.41666;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41667>; else goto <D.41668>;
        <D.41667>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = ins;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        ins->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        goto <D.41669>;
        <D.41668>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = ins;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41669>:
        sp.339 = sp;
        sp = sp.339 + 8;
        *sp.339 = ins;
        ip = ip + 2;
        goto <D.28686>;
      }
      <D.28755>:
      readonly = 1;
      ip = ip + 2;
      goto <D.28686>;
      <D.28756>:
      <D.28757>:
      <D.28758>:
      <D.28759>:
      <D.28760>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41671>; else goto <D.41672>;
      <D.41671>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41673>; else goto <D.41674>;
      <D.41673>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41674>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41672>:
      D.41675 = mini_get_debug_options ();
      D.41676 = D.41675->break_on_unverified;
      if (D.41676 != 0) goto <D.41677>; else goto unverified;
      <D.41677>:
      raise (5);
      <D.28761>:
      D.31987 = ip + 1;
      D.31988 = *D.31987;
      D.32296 = (int) D.31988;
      monoeg_g_log (0B, 16, "opcode 0xfe 0x%02x not handled", D.32296);
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41678>; else goto <D.41679>;
      <D.41678>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41680>; else goto <D.41681>;
      <D.41680>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41681>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41679>:
      D.41682 = mini_get_debug_options ();
      D.41683 = D.41682->break_on_unverified;
      if (D.41683 != 0) goto <D.41684>; else goto unverified;
      <D.41684>:
      raise (5);
      <D.28686>:
      goto <D.27857>;
      <D.28762>:
      <D.28763>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41685>; else goto <D.41686>;
      <D.41685>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41687>; else goto <D.41688>;
      <D.41687>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41688>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41686>:
      D.41689 = mini_get_debug_options ();
      D.41690 = D.41689->break_on_unverified;
      if (D.41690 != 0) goto <D.41691>; else goto unverified;
      <D.41691>:
      raise (5);
      <D.28764>:
      D.31838 = *ip;
      D.31839 = (int) D.31838;
      monoeg_g_log (0B, 16, "opcode 0x%02x not handled", D.31839);
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41692>; else goto <D.41693>;
      <D.41692>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41694>; else goto <D.41695>;
      <D.41694>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41695>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41693>:
      D.41696 = mini_get_debug_options ();
      D.41697 = D.41696->break_on_unverified;
      if (D.41697 != 0) goto <D.41698>; else goto unverified;
      <D.41698>:
      raise (5);
      <D.27857>:
      <D.27852>:
      if (ip < end) goto <D.28765>; else goto <D.28766>;
      <D.28766>:
      if (start_new_bblock != 1) goto <D.41699>; else goto <D.41700>;
      <D.41699>:
      D.31089 = cfg->gsharedvt;
      if (D.31089 != 0) goto <D.41701>; else goto <D.41702>;
      <D.41701>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41703>; else goto <D.41704>;
      <D.41703>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.41704>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.41702>:
      D.41705 = mini_get_debug_options ();
      D.41706 = D.41705->break_on_unverified;
      if (D.41706 != 0) goto <D.41707>; else goto unverified;
      <D.41707>:
      raise (5);
      <D.41700>:
      bblock.70 = bblock;
      ip.75 = (long int) ip;
      bblock.70 = bblock;
      D.31267 = bblock.70->cil_code;
      D.31270 = (long int) D.31267;
      D.31656 = ip.75 - D.31270;
      D.31657 = (int) D.31656;
      bblock.70->cil_length = D.31657;
      bblock.70 = bblock;
      D.41708 = bblock.70->next_bb;
      if (D.41708 != 0B) goto <D.41709>; else goto <D.41710>;
      <D.41709>:
      {
        struct MonoBasicBlock * bb;

        bb = bblock;
        goto <D.28769>;
        <D.28768>:
        bb = bb->next_bb;
        <D.28769>:
        D.41711 = bb->next_bb;
        if (D.41711 != 0B) goto <D.28768>; else goto <D.28770>;
        <D.28770>:
        bb->next_bb = end_bblock;
      }
      goto <D.41712>;
      <D.41710>:
      bblock.70 = bblock;
      bblock.70->next_bb = end_bblock;
      <D.41712>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41713>; else goto <D.41714>;
      <D.41713>:
      D.41715 = cfg->domainvar;
      if (D.41715 != 0B) goto <D.41716>; else goto <D.41717>;
      <D.41716>:
      {
        struct MonoInst * store;
        struct MonoInst * get_domain;

        cfg->cbb = init_localsbb;
        get_domain = mono_get_domain_intrinsic (cfg);
        if (get_domain != 0B) goto <D.41718>; else goto <D.41719>;
        <D.41718>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41720>; else goto <D.41721>;
        <D.41720>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = get_domain;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        get_domain->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = get_domain;
        goto <D.41722>;
        <D.41721>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = get_domain;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41722>:
        goto <D.41723>;
        <D.41719>:
        get_domain = mono_emit_jit_icall (cfg, mono_domain_get, 0B);
        <D.41723>:
        D.30941 = cfg->mempool;
        store = mono_mempool_alloc (D.30941, 80);
        store->data.op[1].const_val = 0;
        D.41724 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.41724;
        store->prev = 0B;
        D.41725 = store->prev;
        store->next = D.41725;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.41726 = store->sreg3;
        store->sreg2 = D.41726;
        D.41727 = store->sreg2;
        store->sreg1 = D.41727;
        D.31162 = cfg->ip;
        store->cil_code = D.31162;
        D.31695 = cfg->varinfo;
        D.41715 = cfg->domainvar;
        D.41728 = D.41715->data.op[0].const_val;
        D.41729 = (long unsigned int) D.41728;
        D.41730 = D.41729 * 8;
        D.41731 = D.31695 + D.41730;
        D.41732 = *D.41731;
        D.41733 = D.41732->data.op[1].vtype;
        D.41734 = mono_type_to_regmove (cfg, D.41733);
        D.41735 = (short unsigned int) D.41734;
        store->opcode = D.41735;
        D.31695 = cfg->varinfo;
        D.41715 = cfg->domainvar;
        D.41728 = D.41715->data.op[0].const_val;
        D.41729 = (long unsigned int) D.41728;
        D.41730 = D.41729 * 8;
        D.41731 = D.31695 + D.41730;
        D.41732 = *D.41731;
        D.41736 = D.41732->klass;
        store->klass = D.41736;
        D.41737 = get_domain->dreg;
        store->sreg1 = D.41737;
        D.31695 = cfg->varinfo;
        D.41715 = cfg->domainvar;
        D.41728 = D.41715->data.op[0].const_val;
        D.41729 = (long unsigned int) D.41728;
        D.41730 = D.41729 * 8;
        D.41731 = D.31695 + D.41730;
        D.41732 = *D.41731;
        D.41738 = D.41732->dreg;
        store->dreg = D.41738;
        D.41739 = store->opcode;
        if (D.41739 == 427) goto <D.41740>; else goto <D.41741>;
        <D.41740>:
        D.31695 = cfg->varinfo;
        D.41715 = cfg->domainvar;
        D.41728 = D.41715->data.op[0].const_val;
        D.41729 = (long unsigned int) D.41728;
        D.41730 = D.41729 * 8;
        D.41731 = D.31695 + D.41730;
        D.41732 = *D.41731;
        D.41733 = D.41732->data.op[1].vtype;
        D.41742 = mono_class_from_mono_type (D.41733);
        store->klass = D.41742;
        <D.41741>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        if (D.31191 != 0B) goto <D.41743>; else goto <D.41744>;
        <D.41743>:
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        D.31191->next = store;
        bblock.113 = cfg->cbb;
        D.31191 = bblock.113->last_ins;
        store->prev = D.31191;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        goto <D.41745>;
        <D.41744>:
        bblock.113 = cfg->cbb;
        bblock.113 = cfg->cbb;
        bblock.113->last_ins = store;
        D.31191 = bblock.113->last_ins;
        bblock.113->code = D.31191;
        <D.41745>:
      }
      <D.41717>:
      <D.41714>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31337 = D.31336 & 274877906944;
      if (D.31337 != 0) goto <D.41746>; else goto <D.41747>;
      <D.41746>:
      mono_get_got_var (cfg);
      <D.41747>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41748>; else goto <D.41749>;
      <D.41748>:
      D.41750 = cfg->got_var;
      if (D.41750 != 0B) goto <D.41751>; else goto <D.41752>;
      <D.41751>:
      mono_emit_load_got_addr (cfg);
      <D.41752>:
      <D.41749>:
      if (init_locals != 0) goto <D.41753>; else goto <D.41754>;
      <D.41753>:
      cfg->cbb = init_localsbb;
      cfg->ip = 0B;
      i = 0;
      goto <D.28774>;
      <D.28773>:
      D.41755 = header->locals[i];
      emit_init_local (cfg, i, D.41755);
      i = i + 1;
      <D.28774>:
      D.31546 = header->num_locals;
      D.31547 = (int) D.31546;
      if (D.31547 > i) goto <D.28773>; else goto <D.28775>;
      <D.28775>:
      <D.41754>:
      D.31336 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.41756 = D.31336 & 2305843009213693952;
      if (D.41756 != 0) goto <D.41757>; else goto <D.41758>;
      <D.41757>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41759>; else goto <D.41760>;
      <D.41759>:
      i = 0;
      goto <D.28779>;
      <D.28778>:
      {
        struct MonoInst * ins;

        D.31695 = cfg->varinfo;
        D.31069 = (long unsigned int) i;
        D.31690 = D.31069 * 8;
        D.41761 = D.31695 + D.31690;
        ins = *D.41761;
        D.41762 = BIT_FIELD_REF <*ins, 64, 0>;
        D.41763 = D.41762 & 16777215;
        if (D.41763 == 393545) goto <D.41764>; else goto <D.41765>;
        <D.41764>:
        {
          struct MonoInst * inst;

          D.30941 = cfg->mempool;
          inst = mono_mempool_alloc (D.30941, 80);
          inst->data.op[1].const_val = 0;
          D.41766 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41766;
          inst->prev = 0B;
          D.41767 = inst->prev;
          inst->next = D.41767;
          inst->opcode = 363;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41768 = inst->sreg3;
          inst->sreg2 = D.41768;
          D.41769 = inst->sreg2;
          inst->sreg1 = D.41769;
          D.31162 = cfg->ip;
          inst->cil_code = D.31162;
          D.41770 = ins->dreg;
          inst->dreg = D.41770;
          inst->data.op[0].p = 0B;
          inst->type = 3;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          if (D.31191 != 0B) goto <D.41771>; else goto <D.41772>;
          <D.41771>:
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          D.31191->next = inst;
          bblock.113 = cfg->cbb;
          D.31191 = bblock.113->last_ins;
          inst->prev = D.31191;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          goto <D.41773>;
          <D.41772>:
          bblock.113 = cfg->cbb;
          bblock.113 = cfg->cbb;
          bblock.113->last_ins = inst;
          D.31191 = bblock.113->last_ins;
          bblock.113->code = D.31191;
          <D.41773>:
        }
        <D.41765>:
      }
      i = i + 1;
      <D.28779>:
      i.104 = (unsigned int) i;
      D.41774 = cfg->num_varinfo;
      if (i.104 < D.41774) goto <D.28778>; else goto <D.28780>;
      <D.28780>:
      <D.41760>:
      <D.41758>:
      D.34459 = cfg->lmf_var;
      if (D.34459 != 0B) goto <D.41775>; else goto <D.41776>;
      <D.41775>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41777>; else goto <D.41778>;
      <D.41777>:
      cfg->cbb = init_localsbb;
      emit_push_lmf (cfg);
      <D.41778>:
      <D.41776>:
      if (seq_points != 0) goto <D.41779>; else goto <D.41780>;
      <D.41779>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.28783>;
        <D.28782>:
        D.41781 = bb->code;
        if (D.41781 != 0B) goto <D.41782>; else goto <D.41783>;
        <D.41782>:
        D.41784 = bb->in_count;
        if (D.41784 > 1) goto <D.41785>; else goto <D.41786>;
        <D.41785>:
        D.41781 = bb->code;
        D.41787 = D.41781->opcode;
        if (D.41787 == 341) goto <D.41788>; else goto <D.41789>;
        <D.41788>:
        D.41781 = bb->code;
        D.41781 = bb->code;
        D.41790 = D.41781->flags;
        D.41791 = D.41790 | 1;
        D.41781->flags = D.41791;
        <D.41789>:
        <D.41786>:
        <D.41783>:
        bb = bb->next_bb;
        <D.28783>:
        if (bb != 0B) goto <D.28782>; else goto <D.28784>;
        <D.28784>:
      }
      <D.41780>:
      if (seq_points != 0) goto <D.41792>; else goto <D.41793>;
      <D.41792>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[1].const_val = -1;
      ins->flags = 0;
      D.41794 = init_localsbb->last_ins;
      if (D.41794 != 0B) goto <D.41795>; else goto <D.41796>;
      <D.41795>:
      D.41794 = init_localsbb->last_ins;
      D.41794->next = ins;
      D.41794 = init_localsbb->last_ins;
      ins->prev = D.41794;
      init_localsbb->last_ins = ins;
      goto <D.41797>;
      <D.41796>:
      init_localsbb->last_ins = ins;
      D.41794 = init_localsbb->last_ins;
      init_localsbb->code = D.41794;
      <D.41797>:
      D.30941 = cfg->mempool;
      ins = mono_mempool_alloc (D.30941, 80);
      ins->data.op[1].const_val = 0;
      D.31158 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.31158;
      ins->prev = 0B;
      D.31159 = ins->prev;
      ins->next = D.31159;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.31160 = ins->sreg3;
      ins->sreg2 = D.31160;
      D.31161 = ins->sreg2;
      ins->sreg1 = D.31161;
      D.31162 = cfg->ip;
      ins->cil_code = D.31162;
      ins->data.op[1].const_val = 16777215;
      ins->flags = 0;
      D.41798 = cfg->bb_exit;
      D.41799 = D.41798->last_ins;
      if (D.41799 != 0B) goto <D.41800>; else goto <D.41801>;
      <D.41800>:
      D.41798 = cfg->bb_exit;
      D.41799 = D.41798->last_ins;
      D.41799->next = ins;
      D.41798 = cfg->bb_exit;
      D.41799 = D.41798->last_ins;
      ins->prev = D.41799;
      D.41798 = cfg->bb_exit;
      D.41798->last_ins = ins;
      goto <D.41802>;
      <D.41801>:
      D.41798 = cfg->bb_exit;
      D.41798 = cfg->bb_exit;
      D.41798->last_ins = ins;
      D.41799 = D.41798->last_ins;
      D.41798->code = D.41799;
      <D.41802>:
      <D.41793>:
      if (sym_seq_points != 0) goto <D.41803>; else goto <D.41804>;
      <D.41803>:
      i = 0;
      goto <D.28787>;
      <D.28786>:
      D.31069 = (long unsigned int) i;
      D.41805 = D.31069 / 64;
      D.41806 = seq_point_locs->data[D.41805];
      D.41807 = i & 63;
      D.41808 = D.41806 >> D.41807;
      D.41809 = D.41808 & 1;
      if (D.41809 != 0) goto <D.41810>; else goto <D.41811>;
      <D.41810>:
      D.31069 = (long unsigned int) i;
      D.41805 = D.31069 / 64;
      D.41812 = seq_point_set_locs->data[D.41805];
      D.41807 = i & 63;
      D.41813 = D.41812 >> D.41807;
      D.41814 = D.41813 & 1;
      if (D.41814 == 0) goto <D.41815>; else goto <D.41816>;
      <D.41815>:
      {
        struct MonoInst * ins;

        D.30941 = cfg->mempool;
        ins = mono_mempool_alloc (D.30941, 80);
        ins->data.op[1].const_val = 0;
        D.41817 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.41817;
        ins->prev = 0B;
        D.41818 = ins->prev;
        ins->next = D.41818;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.41819 = ins->sreg3;
        ins->sreg2 = D.41819;
        D.41820 = ins->sreg2;
        ins->sreg1 = D.41820;
        D.31162 = cfg->ip;
        ins->cil_code = D.31162;
        D.41821 = (long int) i;
        ins->data.op[1].const_val = D.41821;
        ins->flags = 0;
        mono_add_seq_point (cfg, 0B, ins, -1);
      }
      <D.41816>:
      <D.41811>:
      i = i + 1;
      <D.28787>:
      i.340 = (unsigned int) i;
      D.30919 = header->code_size;
      if (i.340 < D.30919) goto <D.28786>; else goto <D.28788>;
      <D.28788>:
      <D.41804>:
      cfg->ip = 0B;
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41823>; else goto <D.41824>;
      <D.41823>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.28791>;
        <D.28790>:
        D.41825 = bb->real_offset;
        D.41826 = (int) D.41825;
        D.41827 = mono_find_block_region (cfg, D.41826);
        D.41828 = (unsigned int) D.41827;
        bb->region = D.41828;
        D.41829 = cfg->spvars;
        if (D.41829 != 0B) goto <D.41830>; else goto <D.41831>;
        <D.41830>:
        D.41832 = bb->region;
        D.41833 = (int) D.41832;
        mono_create_spvar_for_region (cfg, D.41833);
        <D.41831>:
        D.31021 = cfg->verbose_level;
        if (D.31021 > 2) goto <D.41834>; else goto <D.41835>;
        <D.41834>:
        D.41836 = bb->block_num;
        D.41825 = bb->real_offset;
        D.41832 = bb->region;
        printf ("REGION BB%d IL_%04x ID_%08X\n", D.41836, D.41825, D.41832);
        <D.41835>:
        bb = bb->next_bb;
        <D.28791>:
        if (bb != 0B) goto <D.28790>; else goto <D.28792>;
        <D.28792>:
      }
      <D.41824>:
      monoeg_g_slist_free (class_inits);
      dont_inline = monoeg_g_list_remove (dont_inline, method);
      if (inline_costs < 0) goto <D.41837>; else goto <D.41838>;
      <D.41837>:
      {
        char * mname;

        mname = mono_method_full_name (method, 1);
        mono_cfg_set_exception (cfg, 3);
        D.41839 = monoeg_g_strdup_printf ("Method %s is too complex.", mname);
        cfg->exception_message = D.41839;
        monoeg_g_free (mname);
        D.30941 = cfg->mempool;
        D.41840 = cfg->headers_to_free;
        D.41841 = g_slist_prepend_mempool (D.30941, D.41840, header);
        cfg->headers_to_free = D.41841;
        mono_basic_block_free (original_bb);
        D.41842 = -1;
        return D.41842;
      }
      <D.41838>:
      D.31021 = cfg->verbose_level;
      if (D.31021 > 2) goto <D.41843>; else goto <D.41844>;
      <D.41843>:
      D.30911 = cfg->method;
      if (D.30911 == method) goto <D.41845>; else goto <D.41846>;
      <D.41845>:
      mono_print_code (cfg, "AFTER METHOD-TO-IR");
      <D.41846>:
      <D.41844>:
      D.30941 = cfg->mempool;
      D.41840 = cfg->headers_to_free;
      D.41847 = g_slist_prepend_mempool (D.30941, D.41840, header);
      cfg->headers_to_free = D.41847;
      mono_basic_block_free (original_bb);
      D.41842 = inline_costs;
      return D.41842;
      exception_exit:
      D.31510 = cfg->exception_type;
      D.41848 = D.31510 == 0;
      D.41849 = (long int) D.41848;
      D.41850 = __builtin_expect (D.41849, 0);
      if (D.41850 != 0) goto <D.41851>; else goto <D.41852>;
      <D.41851>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12004, "cfg->exception_type != MONO_EXCEPTION_NONE");
      <D.41852>:
      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.30941 = cfg->mempool;
      D.41840 = cfg->headers_to_free;
      D.41853 = g_slist_prepend_mempool (D.30941, D.41840, header);
      cfg->headers_to_free = D.41853;
      D.41842 = -1;
      return D.41842;
    }
  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.41916;
  struct MonoImage * D.41917;
  _Bool D.41918;
  long int D.41919;
  long int D.41920;
  unsigned char D.41923;
  gboolean D.41926;
  unsigned char D.41927;
  struct MonoClass * klass.341;
  struct MonoImage * D.41931;
  struct MonoClass * klass.342;
  struct MonoMethod * D.41939;
  struct MonoClass * D.41941;
  unsigned int D.41942;
  short unsigned int D.41943;
  _Bool D.41944;
  long int D.41945;
  long int D.41946;
  short unsigned int D.41951;
  struct MonoType * D.41953;
  unsigned char D.41954;
  struct MonoType * D.41956;
  unsigned char D.41957;
  char D.41958;
  int D.41959;
  unsigned char D.41960;
  struct MonoAssembly * ass;
  struct MonoCustomAttrInfo * attrs;
  static struct MonoClass * klass;
  int i;
  gboolean val;

  D.41916 = m->klass;
  D.41917 = D.41916->image;
  ass = D.41917->assembly;
  val = 0;
  D.41918 = ass == 0B;
  D.41919 = (long int) D.41918;
  D.41920 = __builtin_expect (D.41919, 0);
  if (D.41920 != 0) goto <D.41921>; else goto <D.41922>;
  <D.41921>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6422, "ass");
  <D.41922>:
  D.41923 = ass->jit_optimizer_disabled_inited;
  if (D.41923 != 0) goto <D.41924>; else goto <D.41925>;
  <D.41924>:
  D.41927 = ass->jit_optimizer_disabled;
  D.41926 = (gboolean) D.41927;
  return D.41926;
  <D.41925>:
  klass.341 = klass;
  if (klass.341 == 0B) goto <D.41929>; else goto <D.41930>;
  <D.41929>:
  D.41931 = mono_defaults.corlib;
  klass.342 = mono_class_from_name (D.41931, "System.Diagnostics", "DebuggableAttribute");
  klass = klass.342;
  <D.41930>:
  klass.341 = klass;
  if (klass.341 == 0B) goto <D.41933>; else goto <D.41934>;
  <D.41933>:
  ass->jit_optimizer_disabled = 0;
  mono_memory_barrier ();
  ass->jit_optimizer_disabled_inited = 1;
  D.41926 = 0;
  return D.41926;
  <D.41934>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs != 0B) goto <D.41935>; else goto <D.41936>;
  <D.41935>:
  i = 0;
  goto <D.27664>;
  <D.27663>:
  {
    struct MonoCustomAttrEntry * attr;
    const gchar * p;
    int len;
    struct MonoMethodSignature * sig;

    attr = &attrs->attrs[i];
    D.41939 = attr->ctor;
    if (D.41939 == 0B) goto <D.41937>; else goto <D.41940>;
    <D.41940>:
    D.41939 = attr->ctor;
    D.41941 = D.41939->klass;
    klass.341 = klass;
    if (D.41941 != klass.341) goto <D.41937>; else goto <D.41938>;
    <D.41937>:
    // predicted unlikely by continue predictor.
    goto <D.27662>;
    <D.41938>:
    D.41942 = attr->data_size;
    len = (int) D.41942;
    p = attr->data;
    D.41943 = MEM[(const guint16 *)p];
    D.41944 = D.41943 != 1;
    D.41945 = (long int) D.41944;
    D.41946 = __builtin_expect (D.41945, 0);
    if (D.41946 != 0) goto <D.41947>; else goto <D.41948>;
    <D.41947>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6449, "read16 (p) == 0x0001");
    <D.41948>:
    p = p + 2;
    D.41939 = attr->ctor;
    sig = mono_method_signature (D.41939);
    D.41951 = sig->param_count;
    if (D.41951 != 2) goto <D.41949>; else goto <D.41952>;
    <D.41952>:
    D.41953 = sig->params[0];
    D.41954 = D.41953->type;
    if (D.41954 != 2) goto <D.41949>; else goto <D.41955>;
    <D.41955>:
    D.41956 = sig->params[1];
    D.41957 = D.41956->type;
    if (D.41957 != 2) goto <D.41949>; else goto <D.41950>;
    <D.41949>:
    // predicted unlikely by continue predictor.
    goto <D.27662>;
    <D.41950>:
    p = p + 1;
    D.41958 = *p;
    val = (gboolean) D.41958;
  }
  <D.27662>:
  i = i + 1;
  <D.27664>:
  D.41959 = attrs->num_attrs;
  if (D.41959 > i) goto <D.27663>; else goto <D.27665>;
  <D.27665>:
  mono_custom_attrs_free (attrs);
  <D.41936>:
  D.41960 = (unsigned char) val;
  ass->jit_optimizer_disabled = D.41960;
  mono_memory_barrier ();
  ass->jit_optimizer_disabled_inited = 1;
  D.41926 = val;
  return D.41926;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_create_exvar_for_offset (struct MonoCompile * cfg, int offset)
{
  struct GHashTable * D.41962;
  long int D.41963;
  const void * D.41964;
  struct MonoInst * D.41967;
  struct MonoClass * D.41968;
  struct MonoType * D.41969;
  unsigned char D.41970;
  unsigned char D.41971;
  void * D.41972;
  struct MonoInst * var;

  D.41962 = cfg->exvars;
  D.41963 = (long int) offset;
  D.41964 = (const void *) D.41963;
  var = monoeg_g_hash_table_lookup (D.41962, D.41964);
  if (var != 0B) goto <D.41965>; else goto <D.41966>;
  <D.41965>:
  D.41967 = var;
  return D.41967;
  <D.41966>:
  D.41968 = mono_defaults.object_class;
  D.41969 = &D.41968->byval_arg;
  var = mono_compile_create_var (cfg, D.41969, 329);
  D.41970 = var->flags;
  D.41971 = D.41970 | 4;
  var->flags = D.41971;
  D.41962 = cfg->exvars;
  D.41963 = (long int) offset;
  D.41972 = (void *) D.41963;
  monoeg_g_hash_table_insert_replace (D.41962, D.41972, var, 0);
  D.41967 = var;
  return D.41967;
}


mono_save_args (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * sp)
{
  struct MonoType * iftmp.343;
  long unsigned int D.41977;
  long unsigned int D.41978;
  struct MonoInst * D.41981;
  <unnamed-unsigned:1> D.41982;
  int D.41983;
  int D.41984;
  struct MonoInst * * D.41985;
  long unsigned int D.41986;
  long unsigned int D.41987;
  struct MonoInst * * D.41988;
  struct MonoMemPool * D.41989;
  long int D.41990;
  struct MonoInst * D.41991;
  int D.41992;
  int D.41993;
  const unsigned char * D.41994;
  struct MonoType * * D.41995;
  struct MonoType * * D.41996;
  struct MonoType * D.41997;
  unsigned int D.41998;
  short unsigned int D.41999;
  struct MonoInst * D.42000;
  struct MonoClass * D.42001;
  int D.42002;
  int D.42003;
  short unsigned int D.42004;
  struct MonoClass * D.42007;
  struct MonoBasicBlock * D.42008;
  struct MonoInst * D.42009;
  const unsigned char * D.42013;
  short unsigned int D.42014;
  int D.42015;
  int D.42016;
  struct MonoInst * store;
  struct MonoInst * temp;
  int i;

  i = 0;
  goto <D.27344>;
  <D.27343>:
  {
    struct MonoType * argtype;

    D.41977 = BIT_FIELD_REF <*sig, 64, 64>;
    D.41978 = D.41977 & 18014398509481984;
    if (D.41978 != 0) goto <D.41979>; else goto <D.41975>;
    <D.41979>:
    if (i == 0) goto <D.41980>; else goto <D.41975>;
    <D.41980>:
    D.41981 = *sp;
    iftmp.343 = type_from_stack_type (D.41981);
    goto <D.41976>;
    <D.41975>:
    D.41982 = sig->hasthis;
    D.41983 = (int) D.41982;
    D.41984 = i - D.41983;
    iftmp.343 = sig->params[D.41984];
    <D.41976>:
    argtype = iftmp.343;
    temp = mono_compile_create_var (cfg, argtype, 329);
    D.41985 = cfg->args;
    D.41986 = (long unsigned int) i;
    D.41987 = D.41986 * 8;
    D.41988 = D.41985 + D.41987;
    *D.41988 = temp;
    D.41989 = cfg->mempool;
    store = mono_mempool_alloc (D.41989, 80);
    store->data.op[1].const_val = 0;
    D.41990 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.41990;
    store->prev = 0B;
    D.41991 = store->prev;
    store->next = D.41991;
    store->opcode = 424;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.41992 = store->sreg3;
    store->sreg2 = D.41992;
    D.41993 = store->sreg2;
    store->sreg1 = D.41993;
    D.41994 = cfg->ip;
    store->cil_code = D.41994;
    D.41995 = cfg->arg_types;
    D.41986 = (long unsigned int) i;
    D.41987 = D.41986 * 8;
    D.41996 = D.41995 + D.41987;
    D.41997 = *D.41996;
    D.41998 = mono_type_to_regmove (cfg, D.41997);
    D.41999 = (short unsigned int) D.41998;
    store->opcode = D.41999;
    D.41985 = cfg->args;
    D.41986 = (long unsigned int) i;
    D.41987 = D.41986 * 8;
    D.41988 = D.41985 + D.41987;
    D.42000 = *D.41988;
    D.42001 = D.42000->klass;
    store->klass = D.42001;
    D.41981 = *sp;
    D.42002 = D.41981->dreg;
    store->sreg1 = D.42002;
    D.41985 = cfg->args;
    D.41986 = (long unsigned int) i;
    D.41987 = D.41986 * 8;
    D.41988 = D.41985 + D.41987;
    D.42000 = *D.41988;
    D.42003 = D.42000->dreg;
    store->dreg = D.42003;
    D.42004 = store->opcode;
    if (D.42004 == 427) goto <D.42005>; else goto <D.42006>;
    <D.42005>:
    D.41995 = cfg->arg_types;
    D.41986 = (long unsigned int) i;
    D.41987 = D.41986 * 8;
    D.41996 = D.41995 + D.41987;
    D.41997 = *D.41996;
    D.42007 = mono_class_from_mono_type (D.41997);
    store->klass = D.42007;
    <D.42006>:
    D.42008 = cfg->cbb;
    D.42009 = D.42008->last_ins;
    if (D.42009 != 0B) goto <D.42010>; else goto <D.42011>;
    <D.42010>:
    D.42008 = cfg->cbb;
    D.42009 = D.42008->last_ins;
    D.42009->next = store;
    D.42008 = cfg->cbb;
    D.42009 = D.42008->last_ins;
    store->prev = D.42009;
    D.42008 = cfg->cbb;
    D.42008->last_ins = store;
    goto <D.42012>;
    <D.42011>:
    D.42008 = cfg->cbb;
    D.42008 = cfg->cbb;
    D.42008->last_ins = store;
    D.42009 = D.42008->last_ins;
    D.42008->code = D.42009;
    <D.42012>:
    D.41981 = *sp;
    D.42013 = D.41981->cil_code;
    store->cil_code = D.42013;
    sp = sp + 8;
  }
  i = i + 1;
  <D.27344>:
  D.42014 = sig->param_count;
  D.42015 = (int) D.42014;
  D.41982 = sig->hasthis;
  D.41983 = (int) D.41982;
  D.42016 = D.42015 + D.41983;
  if (D.42016 > i) goto <D.27343>; else goto <D.27345>;
  <D.27345>:
}


emit_get_rgctx_gsharedvt_method (struct MonoCompile * cfg, int context_used, struct MonoMethod * cmethod, struct MonoGSharedVtMethodInfo * info)
{
  struct MonoMemPool * D.42017;
  struct MonoMethod * D.42018;
  int D.42019;
  struct MonoInst * D.42020;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.42017 = cfg->mempool;
  D.42018 = cfg->current_method;
  D.42019 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.42017, D.42018, D.42019, 46, info, 20);
  D.42018 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.42018, context_used);
  D.42020 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.42020;
}


emit_throw_exception (struct MonoCompile * cfg, struct MonoException * ex)
{
  struct MonoMemPool * D.42022;
  void * D.42023;
  struct MonoInst * D.42024;
  long int D.42025;
  struct MonoInst * D.42026;
  int D.42027;
  int D.42028;
  const unsigned char * D.42029;
  unsigned int D.42030;
  int D.42031;
  struct MonoBasicBlock * D.42032;
  struct MonoInst * D.42033;
  struct MonoMethod * thrower;
  struct MonoInst * args[1];

  try
    {
      thrower = throw_exception ();
      D.42022 = cfg->mempool;
      D.42023 = mono_mempool_alloc (D.42022, 80);
      args[0] = D.42023;
      D.42024 = args[0];
      D.42024 = args[0];
      D.42024->data.op[1].const_val = 0;
      D.42025 = D.42024->data.op[1].const_val;
      D.42024->data.op[0].const_val = D.42025;
      D.42024 = args[0];
      D.42024 = args[0];
      D.42024->prev = 0B;
      D.42026 = D.42024->prev;
      D.42024->next = D.42026;
      D.42024 = args[0];
      D.42024->opcode = 363;
      D.42024 = args[0];
      D.42024->flags = 0;
      D.42024 = args[0];
      D.42024->type = 0;
      D.42024 = args[0];
      D.42024->dreg = -1;
      D.42024 = args[0];
      D.42024 = args[0];
      D.42024 = args[0];
      D.42024->sreg3 = -1;
      D.42027 = D.42024->sreg3;
      D.42024->sreg2 = D.42027;
      D.42028 = D.42024->sreg2;
      D.42024->sreg1 = D.42028;
      D.42024 = args[0];
      D.42029 = cfg->ip;
      D.42024->cil_code = D.42029;
      D.42024 = args[0];
      D.42024->data.op[0].p = ex;
      D.42024 = args[0];
      D.42024->type = 3;
      D.42024 = args[0];
      D.42030 = alloc_dreg (cfg, 3);
      D.42031 = (int) D.42030;
      D.42024->dreg = D.42031;
      D.42032 = cfg->cbb;
      D.42033 = D.42032->last_ins;
      if (D.42033 != 0B) goto <D.42034>; else goto <D.42035>;
      <D.42034>:
      D.42032 = cfg->cbb;
      D.42033 = D.42032->last_ins;
      D.42024 = args[0];
      D.42033->next = D.42024;
      D.42024 = args[0];
      D.42032 = cfg->cbb;
      D.42033 = D.42032->last_ins;
      D.42024->prev = D.42033;
      D.42032 = cfg->cbb;
      D.42024 = args[0];
      D.42032->last_ins = D.42024;
      goto <D.42036>;
      <D.42035>:
      D.42032 = cfg->cbb;
      D.42032 = cfg->cbb;
      D.42024 = args[0];
      D.42032->last_ins = D.42024;
      D.42033 = D.42032->last_ins;
      D.42032->code = D.42033;
      <D.42036>:
      mono_emit_method_call (cfg, thrower, &args, 0B);
    }
  finally
    {
      args = {CLOBBER};
    }
}


throw_exception ()
{
  struct MonoMethod * method.344;
  struct MonoClass * D.42040;
  struct MonoMethod * method.345;
  _Bool D.42042;
  long int D.42043;
  long int D.42044;
  struct MonoMethod * D.42047;
  static struct MonoMethod * method = 0B;

  method.344 = method;
  if (method.344 == 0B) goto <D.42038>; else goto <D.42039>;
  <D.42038>:
  {
    struct MonoSecurityManager * secman;

    secman = mono_security_manager_get_methods ();
    D.42040 = secman->securitymanager;
    method.345 = mono_class_get_method_from_name (D.42040, "ThrowException", 1);
    method = method.345;
  }
  <D.42039>:
  method.344 = method;
  D.42042 = method.344 == 0B;
  D.42043 = (long int) D.42042;
  D.42044 = __builtin_expect (D.42043, 0);
  if (D.42044 != 0) goto <D.42045>; else goto <D.42046>;
  <D.42045>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6187, "method");
  <D.42046>:
  D.42047 = method;
  return D.42047;
}


get_basic_blocks (struct MonoCompile * cfg, struct MonoMethodHeader * header, guint real_offset, unsigned char * start, unsigned char * end, unsigned char * * pos)
{
  unsigned char * ip.346;
  long int ip.347;
  long int start.348;
  long int D.42052;
  <unnamed type> D.42053;
  int D.42056;
  unsigned int D.42059;
  struct MonoDebugOptions * D.42062;
  int D.42063;
  unsigned char D.42065;
  int D.42066;
  unsigned char * ip.349;
  unsigned char * ip.350;
  unsigned char * ip.351;
  unsigned char * ip.352;
  sizetype D.42071;
  unsigned char D.42072;
  signed char D.42073;
  sizetype D.42074;
  sizetype D.42075;
  sizetype D.42076;
  struct MonoBasicBlock * * D.42077;
  long int target.353;
  unsigned char * D.42079;
  long int D.42080;
  long int D.42081;
  long unsigned int D.42082;
  long unsigned int D.42083;
  struct MonoBasicBlock * * D.42084;
  const unsigned char * D.42090;
  struct MonoDebugOptions * D.42095;
  int D.42096;
  struct MonoMemPool * D.42098;
  unsigned int D.42099;
  unsigned int D.42100;
  unsigned int D.42101;
  int D.42102;
  unsigned char * D.42103;
  long int D.42106;
  long int D.42107;
  long unsigned int D.42108;
  long unsigned int D.42109;
  struct MonoBasicBlock * * D.42110;
  unsigned int D.42111;
  long int D.42114;
  long unsigned int D.42115;
  long unsigned int D.42116;
  struct MonoBasicBlock * * D.42117;
  struct MonoDebugOptions * D.42127;
  int D.42128;
  unsigned int D.42130;
  unsigned int D.42131;
  int D.42132;
  const guint32 * D.42135;
  unsigned int D.42136;
  int D.42137;
  sizetype D.42138;
  sizetype D.42139;
  sizetype D.42140;
  struct MonoDebugOptions * D.42150;
  int D.42151;
  unsigned int D.42153;
  unsigned int D.42154;
  int D.42155;
  struct MonoDebugOptions * D.42169;
  int D.42170;
  unsigned int D.42172;
  unsigned int D.42173;
  int D.42174;
  unsigned int D.42177;
  unsigned int D.42178;
  struct MonoDebugOptions * D.42188;
  int D.42189;
  unsigned int D.42191;
  unsigned int D.42192;
  int D.42193;
  unsigned int D.42196;
  int D.42197;
  sizetype D.42198;
  sizetype D.42199;
  struct MonoDebugOptions * D.42209;
  int D.42210;
  unsigned int D.42212;
  unsigned int D.42213;
  int D.42214;
  unsigned char * ip.354;
  unsigned char * ip.355;
  long int bb_start.356;
  long int D.42222;
  long unsigned int D.42223;
  long unsigned int D.42224;
  struct MonoBasicBlock * * D.42225;
  int D.42229;
  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.27492>;
      <D.27491>:
      ip.346 = ip;
      ip.347 = (long int) ip.346;
      start.348 = (long int) start;
      D.42052 = ip.347 - start.348;
      cli_addr = (guint) D.42052;
      D.42053 = mono_opcode_value (&ip, end);
      i = (int) D.42053;
      if (i < 0) goto <D.42054>; else goto <D.42055>;
      <D.42054>:
      D.42056 = cfg->gsharedvt;
      if (D.42056 != 0) goto <D.42057>; else goto <D.42058>;
      <D.42057>:
      D.42059 = cfg->verbose_level;
      if (D.42059 > 2) goto <D.42060>; else goto <D.42061>;
      <D.42060>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.42061>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.42058>:
      D.42062 = mini_get_debug_options ();
      D.42063 = D.42062->break_on_unverified;
      if (D.42063 != 0) goto <D.42064>; else goto unverified;
      <D.42064>:
      raise (5);
      <D.42055>:
      opcode = &mono_opcodes[i];
      D.42065 = opcode->argument;
      D.42066 = (int) D.42065;
      switch (D.42066) <default: <D.27486>, case 0: <D.27463>, case 1: <D.27466>, case 2: <D.27467>, case 3: <D.27468>, case 4: <D.27469>, case 5: <D.27465>, case 6: <D.27470>, case 7: <D.27473>, case 8: <D.27474>, case 9: <D.27477>, case 10: <D.27476>, case 11: <D.27478>, case 12: <D.27484>, case 13: <D.27471>, case 14: <D.27472>, case 15: <D.27475>, case 16: <D.27485>>
      <D.27463>:
      ip.346 = ip;
      ip.349 = ip.346 + 1;
      ip = ip.349;
      goto <D.27464>;
      <D.27465>:
      <D.27466>:
      <D.27467>:
      <D.27468>:
      <D.27469>:
      <D.27470>:
      <D.27471>:
      <D.27472>:
      ip.346 = ip;
      ip.350 = ip.346 + 5;
      ip = ip.350;
      goto <D.27464>;
      <D.27473>:
      ip.346 = ip;
      ip.351 = ip.346 + 3;
      ip = ip.351;
      goto <D.27464>;
      <D.27474>:
      <D.27475>:
      ip.346 = ip;
      ip.352 = ip.346 + 2;
      ip = ip.352;
      goto <D.27464>;
      <D.27476>:
      D.42071 = (sizetype) cli_addr;
      ip.346 = ip;
      ip.349 = ip.346 + 1;
      D.42072 = *ip.349;
      D.42073 = (signed char) D.42072;
      D.42074 = (sizetype) D.42073;
      D.42075 = D.42071 + D.42074;
      D.42076 = D.42075 + 2;
      target = start + D.42076;
      D.42077 = cfg->cil_offset_to_bb;
      target.353 = (long int) target;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42081 = target.353 - D.42080;
      D.42082 = (long unsigned int) D.42081;
      D.42083 = D.42082 * 8;
      D.42084 = D.42077 + D.42083;
      bblock = *D.42084;
      if (bblock == 0B) goto <D.42085>; else goto <D.42086>;
      <D.42085>:
      if (target >= end) goto <D.42087>; else goto <D.42089>;
      <D.42089>:
      D.42090 = header->code;
      if (D.42090 > target) goto <D.42087>; else goto <D.42088>;
      <D.42087>:
      D.42056 = cfg->gsharedvt;
      if (D.42056 != 0) goto <D.42091>; else goto <D.42092>;
      <D.42091>:
      D.42059 = cfg->verbose_level;
      if (D.42059 > 2) goto <D.42093>; else goto <D.42094>;
      <D.42093>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.42094>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.42092>:
      D.42095 = mini_get_debug_options ();
      D.42096 = D.42095->break_on_unverified;
      if (D.42096 != 0) goto <D.42097>; else goto unverified;
      <D.42097>:
      raise (5);
      <D.42088>:
      D.42098 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.42098, 296);
      D.42099 = cfg->num_bblocks;
      D.42100 = D.42099;
      D.42101 = D.42100 + 1;
      cfg->num_bblocks = D.42101;
      D.42102 = (int) D.42100;
      bblock->block_num = D.42102;
      bblock->cil_code = target;
      D.42103 = bblock->cil_code;
      if (D.42103 != 0B) goto <D.42104>; else goto <D.42105>;
      <D.42104>:
      D.42077 = cfg->cil_offset_to_bb;
      D.42103 = bblock->cil_code;
      D.42106 = (long int) D.42103;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42107 = D.42106 - D.42080;
      D.42108 = (long unsigned int) D.42107;
      D.42109 = D.42108 * 8;
      D.42110 = D.42077 + D.42109;
      *D.42110 = bblock;
      <D.42105>:
      D.42111 = cfg->real_offset;
      bblock->real_offset = D.42111;
      <D.42086>:
      ip.346 = ip;
      ip.352 = ip.346 + 2;
      ip = ip.352;
      ip.346 = ip;
      if (ip.346 < end) goto <D.42112>; else goto <D.42113>;
      <D.42112>:
      D.42077 = cfg->cil_offset_to_bb;
      ip.346 = ip;
      ip.347 = (long int) ip.346;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42114 = ip.347 - D.42080;
      D.42115 = (long unsigned int) D.42114;
      D.42116 = D.42115 * 8;
      D.42117 = D.42077 + D.42116;
      bblock = *D.42117;
      if (bblock == 0B) goto <D.42118>; else goto <D.42119>;
      <D.42118>:
      ip.346 = ip;
      if (ip.346 >= end) goto <D.42120>; else goto <D.42122>;
      <D.42122>:
      D.42090 = header->code;
      ip.346 = ip;
      if (D.42090 > ip.346) goto <D.42120>; else goto <D.42121>;
      <D.42120>:
      D.42056 = cfg->gsharedvt;
      if (D.42056 != 0) goto <D.42123>; else goto <D.42124>;
      <D.42123>:
      D.42059 = cfg->verbose_level;
      if (D.42059 > 2) goto <D.42125>; else goto <D.42126>;
      <D.42125>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.42126>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.42124>:
      D.42127 = mini_get_debug_options ();
      D.42128 = D.42127->break_on_unverified;
      if (D.42128 != 0) goto <D.42129>; else goto unverified;
      <D.42129>:
      raise (5);
      <D.42121>:
      D.42098 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.42098, 296);
      D.42099 = cfg->num_bblocks;
      D.42130 = D.42099;
      D.42131 = D.42130 + 1;
      cfg->num_bblocks = D.42131;
      D.42132 = (int) D.42130;
      bblock->block_num = D.42132;
      ip.346 = ip;
      bblock->cil_code = ip.346;
      D.42103 = bblock->cil_code;
      if (D.42103 != 0B) goto <D.42133>; else goto <D.42134>;
      <D.42133>:
      D.42077 = cfg->cil_offset_to_bb;
      D.42103 = bblock->cil_code;
      D.42106 = (long int) D.42103;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42107 = D.42106 - D.42080;
      D.42108 = (long unsigned int) D.42107;
      D.42109 = D.42108 * 8;
      D.42110 = D.42077 + D.42109;
      *D.42110 = bblock;
      <D.42134>:
      D.42111 = cfg->real_offset;
      bblock->real_offset = D.42111;
      <D.42119>:
      <D.42113>:
      goto <D.27464>;
      <D.27477>:
      D.42071 = (sizetype) cli_addr;
      ip.346 = ip;
      D.42135 = ip.346 + 1;
      D.42136 = *D.42135;
      D.42137 = (int) D.42136;
      D.42138 = (sizetype) D.42137;
      D.42139 = D.42071 + D.42138;
      D.42140 = D.42139 + 5;
      target = start + D.42140;
      D.42077 = cfg->cil_offset_to_bb;
      target.353 = (long int) target;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42081 = target.353 - D.42080;
      D.42082 = (long unsigned int) D.42081;
      D.42083 = D.42082 * 8;
      D.42084 = D.42077 + D.42083;
      bblock = *D.42084;
      if (bblock == 0B) goto <D.42141>; else goto <D.42142>;
      <D.42141>:
      if (target >= end) goto <D.42143>; else goto <D.42145>;
      <D.42145>:
      D.42090 = header->code;
      if (D.42090 > target) goto <D.42143>; else goto <D.42144>;
      <D.42143>:
      D.42056 = cfg->gsharedvt;
      if (D.42056 != 0) goto <D.42146>; else goto <D.42147>;
      <D.42146>:
      D.42059 = cfg->verbose_level;
      if (D.42059 > 2) goto <D.42148>; else goto <D.42149>;
      <D.42148>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.42149>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.42147>:
      D.42150 = mini_get_debug_options ();
      D.42151 = D.42150->break_on_unverified;
      if (D.42151 != 0) goto <D.42152>; else goto unverified;
      <D.42152>:
      raise (5);
      <D.42144>:
      D.42098 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.42098, 296);
      D.42099 = cfg->num_bblocks;
      D.42153 = D.42099;
      D.42154 = D.42153 + 1;
      cfg->num_bblocks = D.42154;
      D.42155 = (int) D.42153;
      bblock->block_num = D.42155;
      bblock->cil_code = target;
      D.42103 = bblock->cil_code;
      if (D.42103 != 0B) goto <D.42156>; else goto <D.42157>;
      <D.42156>:
      D.42077 = cfg->cil_offset_to_bb;
      D.42103 = bblock->cil_code;
      D.42106 = (long int) D.42103;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42107 = D.42106 - D.42080;
      D.42108 = (long unsigned int) D.42107;
      D.42109 = D.42108 * 8;
      D.42110 = D.42077 + D.42109;
      *D.42110 = bblock;
      <D.42157>:
      D.42111 = cfg->real_offset;
      bblock->real_offset = D.42111;
      <D.42142>:
      ip.346 = ip;
      ip.350 = ip.346 + 5;
      ip = ip.350;
      ip.346 = ip;
      if (ip.346 < end) goto <D.42158>; else goto <D.42159>;
      <D.42158>:
      D.42077 = cfg->cil_offset_to_bb;
      ip.346 = ip;
      ip.347 = (long int) ip.346;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42114 = ip.347 - D.42080;
      D.42115 = (long unsigned int) D.42114;
      D.42116 = D.42115 * 8;
      D.42117 = D.42077 + D.42116;
      bblock = *D.42117;
      if (bblock == 0B) goto <D.42160>; else goto <D.42161>;
      <D.42160>:
      ip.346 = ip;
      if (ip.346 >= end) goto <D.42162>; else goto <D.42164>;
      <D.42164>:
      D.42090 = header->code;
      ip.346 = ip;
      if (D.42090 > ip.346) goto <D.42162>; else goto <D.42163>;
      <D.42162>:
      D.42056 = cfg->gsharedvt;
      if (D.42056 != 0) goto <D.42165>; else goto <D.42166>;
      <D.42165>:
      D.42059 = cfg->verbose_level;
      if (D.42059 > 2) goto <D.42167>; else goto <D.42168>;
      <D.42167>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.42168>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.42166>:
      D.42169 = mini_get_debug_options ();
      D.42170 = D.42169->break_on_unverified;
      if (D.42170 != 0) goto <D.42171>; else goto unverified;
      <D.42171>:
      raise (5);
      <D.42163>:
      D.42098 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.42098, 296);
      D.42099 = cfg->num_bblocks;
      D.42172 = D.42099;
      D.42173 = D.42172 + 1;
      cfg->num_bblocks = D.42173;
      D.42174 = (int) D.42172;
      bblock->block_num = D.42174;
      ip.346 = ip;
      bblock->cil_code = ip.346;
      D.42103 = bblock->cil_code;
      if (D.42103 != 0B) goto <D.42175>; else goto <D.42176>;
      <D.42175>:
      D.42077 = cfg->cil_offset_to_bb;
      D.42103 = bblock->cil_code;
      D.42106 = (long int) D.42103;
      D.42079 = cfg->cil_start;
      D.42080 = (long int) D.42079;
      D.42107 = D.42106 - D.42080;
      D.42108 = (long unsigned int) D.42107;
      D.42109 = D.42108 * 8;
      D.42110 = D.42077 + D.42109;
      *D.42110 = bblock;
      <D.42176>:
      D.42111 = cfg->real_offset;
      bblock->real_offset = D.42111;
      <D.42161>:
      <D.42159>:
      goto <D.27464>;
      <D.27478>:
      {
        guint32 n;
        guint32 j;

        ip.346 = ip;
        n = MEM[(const guint32 *)ip.346 + 1B];
        ip.346 = ip;
        ip.350 = ip.346 + 5;
        ip = ip.350;
        D.42177 = n * 4;
        D.42178 = D.42177 + cli_addr;
        cli_addr = D.42178 + 5;
        D.42071 = (sizetype) cli_addr;
        target = start + D.42071;
        D.42077 = cfg->cil_offset_to_bb;
        target.353 = (long int) target;
        D.42079 = cfg->cil_start;
        D.42080 = (long int) D.42079;
        D.42081 = target.353 - D.42080;
        D.42082 = (long unsigned int) D.42081;
        D.42083 = D.42082 * 8;
        D.42084 = D.42077 + D.42083;
        bblock = *D.42084;
        if (bblock == 0B) goto <D.42179>; else goto <D.42180>;
        <D.42179>:
        if (target >= end) goto <D.42181>; else goto <D.42183>;
        <D.42183>:
        D.42090 = header->code;
        if (D.42090 > target) goto <D.42181>; else goto <D.42182>;
        <D.42181>:
        D.42056 = cfg->gsharedvt;
        if (D.42056 != 0) goto <D.42184>; else goto <D.42185>;
        <D.42184>:
        D.42059 = cfg->verbose_level;
        if (D.42059 > 2) goto <D.42186>; else goto <D.42187>;
        <D.42186>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.42187>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.42185>:
        D.42188 = mini_get_debug_options ();
        D.42189 = D.42188->break_on_unverified;
        if (D.42189 != 0) goto <D.42190>; else goto unverified;
        <D.42190>:
        raise (5);
        <D.42182>:
        D.42098 = cfg->mempool;
        bblock = mono_mempool_alloc0 (D.42098, 296);
        D.42099 = cfg->num_bblocks;
        D.42191 = D.42099;
        D.42192 = D.42191 + 1;
        cfg->num_bblocks = D.42192;
        D.42193 = (int) D.42191;
        bblock->block_num = D.42193;
        bblock->cil_code = target;
        D.42103 = bblock->cil_code;
        if (D.42103 != 0B) goto <D.42194>; else goto <D.42195>;
        <D.42194>:
        D.42077 = cfg->cil_offset_to_bb;
        D.42103 = bblock->cil_code;
        D.42106 = (long int) D.42103;
        D.42079 = cfg->cil_start;
        D.42080 = (long int) D.42079;
        D.42107 = D.42106 - D.42080;
        D.42108 = (long unsigned int) D.42107;
        D.42109 = D.42108 * 8;
        D.42110 = D.42077 + D.42109;
        *D.42110 = bblock;
        <D.42195>:
        D.42111 = cfg->real_offset;
        bblock->real_offset = D.42111;
        <D.42180>:
        j = 0;
        goto <D.27482>;
        <D.27481>:
        D.42071 = (sizetype) cli_addr;
        ip.346 = ip;
        D.42196 = MEM[(const guint32 *)ip.346];
        D.42197 = (int) D.42196;
        D.42198 = (sizetype) D.42197;
        D.42199 = D.42071 + D.42198;
        target = start + D.42199;
        D.42077 = cfg->cil_offset_to_bb;
        target.353 = (long int) target;
        D.42079 = cfg->cil_start;
        D.42080 = (long int) D.42079;
        D.42081 = target.353 - D.42080;
        D.42082 = (long unsigned int) D.42081;
        D.42083 = D.42082 * 8;
        D.42084 = D.42077 + D.42083;
        bblock = *D.42084;
        if (bblock == 0B) goto <D.42200>; else goto <D.42201>;
        <D.42200>:
        if (target >= end) goto <D.42202>; else goto <D.42204>;
        <D.42204>:
        D.42090 = header->code;
        if (D.42090 > target) goto <D.42202>; else goto <D.42203>;
        <D.42202>:
        D.42056 = cfg->gsharedvt;
        if (D.42056 != 0) goto <D.42205>; else goto <D.42206>;
        <D.42205>:
        D.42059 = cfg->verbose_level;
        if (D.42059 > 2) goto <D.42207>; else goto <D.42208>;
        <D.42207>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.42208>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.42206>:
        D.42209 = mini_get_debug_options ();
        D.42210 = D.42209->break_on_unverified;
        if (D.42210 != 0) goto <D.42211>; else goto unverified;
        <D.42211>:
        raise (5);
        <D.42203>:
        D.42098 = cfg->mempool;
        bblock = mono_mempool_alloc0 (D.42098, 296);
        D.42099 = cfg->num_bblocks;
        D.42212 = D.42099;
        D.42213 = D.42212 + 1;
        cfg->num_bblocks = D.42213;
        D.42214 = (int) D.42212;
        bblock->block_num = D.42214;
        bblock->cil_code = target;
        D.42103 = bblock->cil_code;
        if (D.42103 != 0B) goto <D.42215>; else goto <D.42216>;
        <D.42215>:
        D.42077 = cfg->cil_offset_to_bb;
        D.42103 = bblock->cil_code;
        D.42106 = (long int) D.42103;
        D.42079 = cfg->cil_start;
        D.42080 = (long int) D.42079;
        D.42107 = D.42106 - D.42080;
        D.42108 = (long unsigned int) D.42107;
        D.42109 = D.42108 * 8;
        D.42110 = D.42077 + D.42109;
        *D.42110 = bblock;
        <D.42216>:
        D.42111 = cfg->real_offset;
        bblock->real_offset = D.42111;
        <D.42201>:
        ip.346 = ip;
        ip.354 = ip.346 + 4;
        ip = ip.354;
        j = j + 1;
        <D.27482>:
        if (j < n) goto <D.27481>; else goto <D.27483>;
        <D.27483>:
        goto <D.27464>;
      }
      <D.27484>:
      <D.27485>:
      ip.346 = ip;
      ip.355 = ip.346 + 9;
      ip = ip.355;
      goto <D.27464>;
      <D.27486>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 6056);
      <D.27464>:
      if (i == 122) goto <D.42219>; else goto <D.42220>;
      <D.42219>:
      {
        unsigned char * bb_start;

        ip.346 = ip;
        bb_start = ip.346 + 18446744073709551615;
        bblock = 0B;
        goto <D.27489>;
        <D.27488>:
        D.42077 = cfg->cil_offset_to_bb;
        bb_start.356 = (long int) bb_start;
        start.348 = (long int) start;
        D.42222 = bb_start.356 - start.348;
        D.42223 = (long unsigned int) D.42222;
        D.42224 = D.42223 * 8;
        D.42225 = D.42077 + D.42224;
        bblock = *D.42225;
        bb_start = bb_start + 18446744073709551615;
        <D.27489>:
        if (bb_start >= start) goto <D.42226>; else goto <D.27490>;
        <D.42226>:
        if (bblock == 0B) goto <D.27488>; else goto <D.27490>;
        <D.27490>:
        if (bblock != 0B) goto <D.42227>; else goto <D.42228>;
        <D.42227>:
        bblock->out_of_line = 1;
        <D.42228>:
      }
      <D.42220>:
      <D.27492>:
      ip.346 = ip;
      if (ip.346 < end) goto <D.27491>; else goto <D.27493>;
      <D.27493>:
      D.42229 = 0;
      return D.42229;
      unverified:
      exception_exit:
      ip.346 = ip;
      *pos = ip.346;
      D.42229 = 1;
      return D.42229;
    }
  finally
    {
      ip = {CLOBBER};
    }
}


should_insert_brekpoint (struct MonoMethod * method)
{
  MonoBreakPolicy (*<T356d>) (struct MonoMethod *) break_policy_func.357;
  <unnamed type> D.42233;
  gboolean D.42234;

  break_policy_func.357 = break_policy_func;
  D.42233 = break_policy_func.357 (method);
  switch (D.42233) <default: <D.26728>, case 0: <D.26725>, case 1: <D.26726>, case 2: <D.26727>>
  <D.26725>:
  D.42234 = 1;
  return D.42234;
  <D.26726>:
  D.42234 = 0;
  return D.42234;
  <D.26727>:
  monoeg_g_log (0B, 16, "mdb no longer supported");
  D.42234 = 0;
  return D.42234;
  <D.26728>:
  monoeg_g_log (0B, 16, "Incorrect value returned from break policy callback");
  D.42234 = 0;
  return D.42234;
}


mini_get_signature (struct MonoMethod * method, guint32 token, struct MonoGenericContext * context)
{
  long unsigned int D.42236;
  long unsigned int D.42237;
  int D.42242;
  _Bool D.42243;
  long int D.42244;
  long int D.42245;
  struct MonoClass * D.42249;
  struct MonoImage * D.42250;
  struct MonoMethodSignature * D.42251;
  struct MonoMethodSignature * fsig;

  D.42236 = BIT_FIELD_REF <*method, 64, 256>;
  D.42237 = D.42236 & 124;
  if (D.42237 != 0) goto <D.42238>; else goto <D.42239>;
  <D.42238>:
  {
    struct MonoError error;

    try
      {
        fsig = mono_method_get_wrapper_data (method, token);
        if (context != 0B) goto <D.42240>; else goto <D.42241>;
        <D.42240>:
        fsig = mono_inflate_generic_signature (fsig, context, &error);
        D.42242 = mono_error_ok (&error);
        D.42243 = D.42242 == 0;
        D.42244 = (long int) D.42243;
        D.42245 = __builtin_expect (D.42244, 0);
        if (D.42245 != 0) goto <D.42246>; else goto <D.42247>;
        <D.42246>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6135, "mono_error_ok (&error)");
        <D.42247>:
        <D.42241>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.42248>;
  <D.42239>:
  D.42249 = method->klass;
  D.42250 = D.42249->image;
  fsig = mono_metadata_parse_signature (D.42250, token);
  <D.42248>:
  D.42251 = fsig;
  return D.42251;
}


mini_get_method_allow_open (struct MonoMethod * m, guint32 token, struct MonoClass * klass, struct MonoGenericContext * context)
{
  long unsigned int D.42253;
  long unsigned int D.42254;
  struct MonoClass * D.42260;
  struct MonoImage * D.42261;
  struct MonoMethod * D.42262;
  struct MonoMethod * method;

  D.42253 = BIT_FIELD_REF <*m, 64, 256>;
  D.42254 = D.42253 & 124;
  if (D.42254 != 0) goto <D.42255>; else goto <D.42256>;
  <D.42255>:
  method = mono_method_get_wrapper_data (m, token);
  if (context != 0B) goto <D.42257>; else goto <D.42258>;
  <D.42257>:
  method = mono_class_inflate_generic_method (method, context);
  <D.42258>:
  goto <D.42259>;
  <D.42256>:
  D.42260 = m->klass;
  D.42261 = D.42260->image;
  method = mono_get_method_full (D.42261, token, klass, context);
  <D.42259>:
  D.42262 = method;
  return D.42262;
}


mini_emit_inst_for_sharable_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * D.42264;
  struct MonoClass * D.42265;
  int D.26882;
  int iftmp.358;
  int D.26881;
  const char[12] * D.42271;
  unsigned char D.42272;
  int D.42273;
  unsigned char D.42274;
  int D.42275;
  const unsigned char * D.42280;
  unsigned char D.42281;
  int D.42282;
  const unsigned char * D.42283;
  unsigned char D.42284;
  int D.42285;
  const unsigned char * D.42290;
  unsigned char D.42291;
  int D.42292;
  const unsigned char * D.42293;
  unsigned char D.42294;
  int D.42295;
  const unsigned char * D.42300;
  unsigned char D.42301;
  int D.42302;
  const unsigned char * D.42303;
  unsigned char D.42304;
  int D.42305;
  const char * D.42307;
  struct MonoInst * D.42310;
  int D.26891;
  int iftmp.359;
  int D.26890;
  const char[11] * D.42314;
  unsigned char D.42315;
  int D.42316;
  unsigned char D.42317;
  int D.42318;
  const unsigned char * D.42323;
  unsigned char D.42324;
  int D.42325;
  const unsigned char * D.42326;
  unsigned char D.42327;
  int D.42328;
  const unsigned char * D.42333;
  unsigned char D.42334;
  int D.42335;
  const unsigned char * D.42336;
  unsigned char D.42337;
  int D.42338;
  const unsigned char * D.42343;
  unsigned char D.42344;
  int D.42345;
  const unsigned char * D.42346;
  unsigned char D.42347;
  int D.42348;

  D.42264 = cmethod->klass;
  D.42265 = mono_defaults.array_class;
  if (D.42264 == D.42265) goto <D.42266>; else goto <D.42267>;
  <D.42266>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.42269>; else goto <D.42270>;
    <D.42269>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42271 = "UnsafeStore";
      D.42272 = MEM[(const unsigned char *)D.42271];
      D.42273 = (int) D.42272;
      D.42274 = *__s2;
      D.42275 = (int) D.42274;
      __result = D.42273 - D.42275;
      {
        if (__s2_len != 0) goto <D.42276>; else goto <D.42277>;
        <D.42276>:
        if (__result == 0) goto <D.42278>; else goto <D.42279>;
        <D.42278>:
        D.42280 = &MEM[(void *)"UnsafeStore" + 1B];
        D.42281 = *D.42280;
        D.42282 = (int) D.42281;
        D.42283 = __s2 + 1;
        D.42284 = *D.42283;
        D.42285 = (int) D.42284;
        __result = D.42282 - D.42285;
        if (__s2_len > 1) goto <D.42286>; else goto <D.42287>;
        <D.42286>:
        if (__result == 0) goto <D.42288>; else goto <D.42289>;
        <D.42288>:
        D.42290 = &MEM[(void *)"UnsafeStore" + 2B];
        D.42291 = *D.42290;
        D.42292 = (int) D.42291;
        D.42293 = __s2 + 2;
        D.42294 = *D.42293;
        D.42295 = (int) D.42294;
        __result = D.42292 - D.42295;
        if (__s2_len > 2) goto <D.42296>; else goto <D.42297>;
        <D.42296>:
        if (__result == 0) goto <D.42298>; else goto <D.42299>;
        <D.42298>:
        D.42300 = &MEM[(void *)"UnsafeStore" + 3B];
        D.42301 = *D.42300;
        D.42302 = (int) D.42301;
        D.42303 = __s2 + 3;
        D.42304 = *D.42303;
        D.42305 = (int) D.42304;
        __result = D.42302 - D.42305;
        <D.42299>:
        <D.42297>:
        <D.42289>:
        <D.42287>:
        <D.42279>:
        <D.42277>:
      }
      D.26881 = __result;
    }
    iftmp.358 = -D.26881;
    goto <D.42306>;
    <D.42270>:
    D.42307 = cmethod->name;
    iftmp.358 = __builtin_strcmp (D.42307, "UnsafeStore");
    <D.42306>:
    D.26882 = iftmp.358;
  }
  if (D.26882 == 0) goto <D.42308>; else goto <D.42309>;
  <D.42308>:
  D.42310 = emit_array_unsafe_access (cfg, fsig, args, 1);
  return D.42310;
  <D.42309>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.42312>; else goto <D.42313>;
    <D.42312>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42314 = "UnsafeLoad";
      D.42315 = MEM[(const unsigned char *)D.42314];
      D.42316 = (int) D.42315;
      D.42317 = *__s2;
      D.42318 = (int) D.42317;
      __result = D.42316 - D.42318;
      {
        if (__s2_len != 0) goto <D.42319>; else goto <D.42320>;
        <D.42319>:
        if (__result == 0) goto <D.42321>; else goto <D.42322>;
        <D.42321>:
        D.42323 = &MEM[(void *)"UnsafeLoad" + 1B];
        D.42324 = *D.42323;
        D.42325 = (int) D.42324;
        D.42326 = __s2 + 1;
        D.42327 = *D.42326;
        D.42328 = (int) D.42327;
        __result = D.42325 - D.42328;
        if (__s2_len > 1) goto <D.42329>; else goto <D.42330>;
        <D.42329>:
        if (__result == 0) goto <D.42331>; else goto <D.42332>;
        <D.42331>:
        D.42333 = &MEM[(void *)"UnsafeLoad" + 2B];
        D.42334 = *D.42333;
        D.42335 = (int) D.42334;
        D.42336 = __s2 + 2;
        D.42337 = *D.42336;
        D.42338 = (int) D.42337;
        __result = D.42335 - D.42338;
        if (__s2_len > 2) goto <D.42339>; else goto <D.42340>;
        <D.42339>:
        if (__result == 0) goto <D.42341>; else goto <D.42342>;
        <D.42341>:
        D.42343 = &MEM[(void *)"UnsafeLoad" + 3B];
        D.42344 = *D.42343;
        D.42345 = (int) D.42344;
        D.42346 = __s2 + 3;
        D.42347 = *D.42346;
        D.42348 = (int) D.42347;
        __result = D.42345 - D.42348;
        <D.42342>:
        <D.42340>:
        <D.42332>:
        <D.42330>:
        <D.42322>:
        <D.42320>:
      }
      D.26890 = __result;
    }
    iftmp.359 = -D.26890;
    goto <D.42349>;
    <D.42313>:
    D.42307 = cmethod->name;
    iftmp.359 = __builtin_strcmp (D.42307, "UnsafeLoad");
    <D.42349>:
    D.26891 = iftmp.359;
  }
  if (D.26891 == 0) goto <D.42350>; else goto <D.42351>;
  <D.42350>:
  D.42310 = emit_array_unsafe_access (cfg, fsig, args, 0);
  return D.42310;
  <D.42351>:
  <D.42267>:
  D.42310 = 0B;
  return D.42310;
}


emit_array_unsafe_access (struct MonoCompile * cfg, struct MonoMethodSignature * fsig, struct MonoInst * * args, int is_set)
{
  struct MonoType * D.42355;
  struct MonoType * D.42357;
  struct MonoInst * D.42360;
  struct MonoInst * D.42361;
  struct MonoInst * * D.42362;
  struct MonoInst * D.42363;
  struct MonoMemPool * D.42364;
  long int D.42365;
  struct MonoInst * D.42366;
  struct MonoType * D.42367;
  unsigned int D.42368;
  short unsigned int D.42369;
  int D.42370;
  int D.42371;
  const unsigned char * D.42372;
  int D.42373;
  unsigned char D.42374;
  <unnamed type> D.42375;
  unsigned int D.42376;
  int D.42377;
  struct MonoBasicBlock * D.42378;
  struct MonoInst * D.42379;
  struct MonoClass * eklass;

  if (is_set != 0) goto <D.42353>; else goto <D.42354>;
  <D.42353>:
  D.42355 = fsig->params[2];
  eklass = mono_class_from_mono_type (D.42355);
  goto <D.42356>;
  <D.42354>:
  D.42357 = fsig->ret;
  eklass = mono_class_from_mono_type (D.42357);
  <D.42356>:
  if (is_set != 0) goto <D.42358>; else goto <D.42359>;
  <D.42358>:
  D.42360 = emit_array_store (cfg, eklass, args, 0);
  return D.42360;
  <D.42359>:
  {
    struct MonoInst * ins;
    struct MonoInst * addr;

    D.42361 = *args;
    D.42362 = args + 8;
    D.42363 = *D.42362;
    addr = mini_emit_ldelema_1_ins (cfg, eklass, D.42361, D.42363, 0);
    D.42364 = cfg->mempool;
    ins = mono_mempool_alloc (D.42364, 80);
    ins->data.op[1].const_val = 0;
    D.42365 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42365;
    ins->prev = 0B;
    D.42366 = ins->prev;
    ins->next = D.42366;
    D.42367 = &eklass->byval_arg;
    D.42368 = mono_type_to_load_membase (cfg, D.42367);
    D.42369 = (short unsigned int) D.42368;
    ins->opcode = D.42369;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42370 = ins->sreg3;
    ins->sreg2 = D.42370;
    D.42371 = ins->sreg2;
    ins->sreg1 = D.42371;
    D.42372 = cfg->ip;
    ins->cil_code = D.42372;
    ins->dreg = 0;
    D.42373 = addr->dreg;
    ins->sreg1 = D.42373;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.42367 = &eklass->byval_arg;
    type_to_eval_stack_type (cfg, D.42367, ins);
    D.42374 = ins->type;
    D.42375 = (<unnamed type>) D.42374;
    D.42376 = alloc_dreg (cfg, D.42375);
    D.42377 = (int) D.42376;
    ins->dreg = D.42377;
    D.42378 = cfg->cbb;
    D.42379 = D.42378->last_ins;
    if (D.42379 != 0B) goto <D.42380>; else goto <D.42381>;
    <D.42380>:
    D.42378 = cfg->cbb;
    D.42379 = D.42378->last_ins;
    D.42379->next = ins;
    D.42378 = cfg->cbb;
    D.42379 = D.42378->last_ins;
    ins->prev = D.42379;
    D.42378 = cfg->cbb;
    D.42378->last_ins = ins;
    goto <D.42382>;
    <D.42381>:
    D.42378 = cfg->cbb;
    D.42378 = cfg->cbb;
    D.42378->last_ins = ins;
    D.42379 = D.42378->last_ins;
    D.42378->code = D.42379;
    <D.42382>:
    D.42360 = ins;
    return D.42360;
  }
}


check_method_sharing (struct MonoCompile * cfg, struct MonoMethod * cmethod, gboolean * out_pass_vtable, gboolean * out_pass_mrgctx)
{
  short unsigned int D.42387;
  int D.42388;
  int D.42389;
  struct MonoClass * D.42391;
  long unsigned int D.42392;
  long unsigned int D.42393;
  struct MonoGenericClass * D.42394;
  struct MonoGenericContainer * D.42396;
  int D.42397;
  int iftmp.360;
  struct MonoGenericContext * D.42410;
  struct MonoGenericContext * D.42412;
  struct MonoGenericInst * D.42413;
  struct MonoGenericContext * D.42414;
  struct MonoGenericContext * D.42417;
  struct MonoGenericInst * D.42418;
  _Bool D.42421;
  long int D.42422;
  long int D.42423;
  int D.42426;
  int D.42434;
  struct MonoMethodSignature * D.42437;
  int D.42438;
  gboolean pass_vtable;
  gboolean pass_mrgctx;

  pass_vtable = 0;
  pass_mrgctx = 0;
  D.42387 = cmethod->flags;
  D.42388 = (int) D.42387;
  D.42389 = D.42388 & 16;
  if (D.42389 != 0) goto <D.42386>; else goto <D.42390>;
  <D.42390>:
  D.42391 = cmethod->klass;
  D.42392 = BIT_FIELD_REF <*D.42391, 64, 256>;
  D.42393 = D.42392 & 8;
  if (D.42393 != 0) goto <D.42386>; else goto <D.42385>;
  <D.42386>:
  D.42391 = cmethod->klass;
  D.42394 = D.42391->generic_class;
  if (D.42394 != 0B) goto <D.42384>; else goto <D.42395>;
  <D.42395>:
  D.42391 = cmethod->klass;
  D.42396 = D.42391->generic_container;
  if (D.42396 != 0B) goto <D.42384>; else goto <D.42385>;
  <D.42384>:
  {
    gboolean sharable;

    sharable = 0;
    D.42397 = mono_method_is_generic_sharable (cmethod, 1);
    if (D.42397 != 0) goto <D.42398>; else goto <D.42399>;
    <D.42398>:
    sharable = 1;
    goto <D.42400>;
    <D.42399>:
    {
      gboolean sharing_enabled;
      struct MonoGenericContext * context;
      gboolean context_sharable;

      D.42391 = cmethod->klass;
      sharing_enabled = mono_class_generic_sharing_enabled (D.42391);
      D.42391 = cmethod->klass;
      context = mini_class_get_context (D.42391);
      context_sharable = mono_generic_context_is_sharable (context, 1);
      if (sharing_enabled != 0) goto <D.42404>; else goto <D.42402>;
      <D.42404>:
      if (context_sharable != 0) goto <D.42405>; else goto <D.42402>;
      <D.42405>:
      iftmp.360 = 1;
      goto <D.42403>;
      <D.42402>:
      iftmp.360 = 0;
      <D.42403>:
      sharable = iftmp.360;
    }
    <D.42400>:
    if (sharable != 0) goto <D.42408>; else goto <D.42409>;
    <D.42408>:
    D.42410 = mini_method_get_context (cmethod);
    if (D.42410 == 0B) goto <D.42406>; else goto <D.42411>;
    <D.42411>:
    D.42412 = mini_method_get_context (cmethod);
    D.42413 = D.42412->method_inst;
    if (D.42413 == 0B) goto <D.42406>; else goto <D.42407>;
    <D.42406>:
    pass_vtable = 1;
    <D.42407>:
    <D.42409>:
  }
  <D.42385>:
  D.42414 = mini_method_get_context (cmethod);
  if (D.42414 != 0B) goto <D.42415>; else goto <D.42416>;
  <D.42415>:
  D.42417 = mini_method_get_context (cmethod);
  D.42418 = D.42417->method_inst;
  if (D.42418 != 0B) goto <D.42419>; else goto <D.42420>;
  <D.42419>:
  D.42421 = pass_vtable != 0;
  D.42422 = (long int) D.42421;
  D.42423 = __builtin_expect (D.42422, 0);
  if (D.42423 != 0) goto <D.42424>; else goto <D.42425>;
  <D.42424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2418, "!pass_vtable");
  <D.42425>:
  D.42426 = mono_method_is_generic_sharable (cmethod, 1);
  if (D.42426 != 0) goto <D.42427>; else goto <D.42428>;
  <D.42427>:
  pass_mrgctx = 1;
  goto <D.42429>;
  <D.42428>:
  {
    gboolean sharing_enabled;
    struct MonoGenericContext * context;
    gboolean context_sharable;

    D.42391 = cmethod->klass;
    sharing_enabled = mono_class_generic_sharing_enabled (D.42391);
    context = mini_method_get_context (cmethod);
    context_sharable = mono_generic_context_is_sharable (context, 1);
    if (sharing_enabled != 0) goto <D.42430>; else goto <D.42431>;
    <D.42430>:
    if (context_sharable != 0) goto <D.42432>; else goto <D.42433>;
    <D.42432>:
    pass_mrgctx = 1;
    <D.42433>:
    <D.42431>:
    D.42434 = cfg->gsharedvt;
    if (D.42434 != 0) goto <D.42435>; else goto <D.42436>;
    <D.42435>:
    D.42437 = mono_method_signature (cmethod);
    D.42438 = mini_is_gsharedvt_signature (cfg, D.42437);
    if (D.42438 != 0) goto <D.42439>; else goto <D.42440>;
    <D.42439>:
    pass_mrgctx = 1;
    <D.42440>:
    <D.42436>:
  }
  <D.42429>:
  <D.42420>:
  <D.42416>:
  if (out_pass_vtable != 0B) goto <D.42441>; else goto <D.42442>;
  <D.42441>:
  *out_pass_vtable = pass_vtable;
  <D.42442>:
  if (out_pass_mrgctx != 0B) goto <D.42443>; else goto <D.42444>;
  <D.42443>:
  *out_pass_mrgctx = pass_mrgctx;
  <D.42444>:
}


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.42445;
  int D.42446;
  struct MonoType * D.42447;
  struct MonoClass * D.42448;
  struct MonoClass * D.42449;
  struct MonoClass * D.42450;
  struct MonoClass * D.42451;
  struct MonoClass * D.42452;
  struct MonoClass * D.42453;

  D.42445 = ins->type;
  D.42446 = (int) D.42445;
  switch (D.42446) <default: <D.25209>, case 1: <D.25202>, case 2: <D.25203>, case 3: <D.25204>, case 4: <D.25205>, case 5: <D.25206>, case 6: <D.25207>, case 7: <D.25208>>
  <D.25202>:
  D.42448 = mono_defaults.int32_class;
  D.42447 = &D.42448->byval_arg;
  return D.42447;
  <D.25203>:
  D.42449 = mono_defaults.int64_class;
  D.42447 = &D.42449->byval_arg;
  return D.42447;
  <D.25204>:
  D.42450 = mono_defaults.int_class;
  D.42447 = &D.42450->byval_arg;
  return D.42447;
  <D.25205>:
  D.42451 = mono_defaults.double_class;
  D.42447 = &D.42451->byval_arg;
  return D.42447;
  <D.25206>:
  D.42452 = ins->klass;
  D.42447 = &D.42452->this_arg;
  return D.42447;
  <D.25207>:
  D.42453 = mono_defaults.object_class;
  D.42447 = &D.42453->byval_arg;
  return D.42447;
  <D.25208>:
  D.42452 = ins->klass;
  D.42447 = &D.42452->byval_arg;
  return D.42447;
  <D.25209>:
  D.42445 = ins->type;
  D.42446 = (int) D.42445;
  monoeg_g_log (0B, 4, "stack type %d to monotype not handled\n", D.42446);
  <D.25210>:
  goto <D.25210>;
  D.42447 = 0B;
  return D.42447;
}


mini_emit_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * runtime_helpers_class.361;
  struct MonoImage * D.42458;
  struct MonoClass * runtime_helpers_class.362;
  struct MonoClass * D.42460;
  struct MonoClass * D.42461;
  int D.26908;
  int iftmp.363;
  int D.26907;
  const char[10] * D.42467;
  unsigned char D.42468;
  int D.42469;
  unsigned char D.42470;
  int D.42471;
  const unsigned char * D.42476;
  unsigned char D.42477;
  int D.42478;
  const unsigned char * D.42479;
  unsigned char D.42480;
  int D.42481;
  const unsigned char * D.42486;
  unsigned char D.42487;
  int D.42488;
  const unsigned char * D.42489;
  unsigned char D.42490;
  int D.42491;
  const unsigned char * D.42496;
  unsigned char D.42497;
  int D.42498;
  const unsigned char * D.42499;
  unsigned char D.42500;
  int D.42501;
  const char * D.42503;
  unsigned int D.42506;
  unsigned int D.42507;
  unsigned int D.42508;
  unsigned int D.42509;
  struct MonoMemPool * D.42510;
  long int D.42511;
  struct MonoInst * D.42512;
  int D.42513;
  int D.42514;
  const unsigned char * D.42515;
  struct MonoInst * * D.42516;
  struct MonoInst * D.42517;
  int D.42518;
  struct MonoBasicBlock * D.42519;
  struct MonoInst * D.42520;
  unsigned int D.42524;
  unsigned int D.42525;
  unsigned int D.42528;
  long unsigned int D.42531;
  long unsigned int D.42532;
  long int D.42535;
  struct MonoInst * D.42536;
  int D.42537;
  int D.42538;
  struct MonoInst * D.42539;
  int D.42540;
  long int D.42544;
  struct MonoInst * D.42545;
  int D.42546;
  int D.42547;
  unsigned int D.42554;
  int D.42557;
  long int D.42562;
  struct MonoInst * D.42563;
  int D.42564;
  int D.42565;
  long int D.42569;
  struct MonoInst * D.42570;
  int D.42571;
  int D.42572;
  long int D.42577;
  struct MonoInst * D.42578;
  int D.42579;
  int D.42580;
  unsigned char D.42581;
  int D.42586;
  long int D.42591;
  struct MonoInst * D.42592;
  int D.42593;
  int D.42594;
  long int D.42598;
  struct MonoInst * D.42599;
  int D.42600;
  int D.42601;
  long int D.42606;
  struct MonoInst * D.42607;
  int D.42608;
  int D.42609;
  unsigned char D.42610;
  long int D.42614;
  struct MonoInst * D.42615;
  int D.42616;
  int D.42617;
  long int D.42621;
  struct MonoInst * D.42622;
  int D.42623;
  int D.42624;
  unsigned int D.42629;
  int D.42632;
  long int D.42637;
  struct MonoInst * D.42638;
  int D.42639;
  int D.42640;
  long int D.42644;
  struct MonoInst * D.42645;
  int D.42646;
  int D.42647;
  long int D.42652;
  struct MonoInst * D.42653;
  int D.42654;
  int D.42655;
  unsigned char D.42656;
  int D.42661;
  long int D.42666;
  struct MonoInst * D.42667;
  int D.42668;
  int D.42669;
  long int D.42673;
  struct MonoInst * D.42674;
  int D.42675;
  int D.42676;
  long int D.42681;
  struct MonoInst * D.42682;
  int D.42683;
  int D.42684;
  unsigned char D.42685;
  long int D.42689;
  struct MonoInst * D.42690;
  int D.42691;
  int D.42692;
  long int D.42696;
  struct MonoInst * D.42697;
  int D.42698;
  int D.42699;
  long int D.42704;
  struct MonoInst * D.42705;
  int D.42706;
  int D.42707;
  unsigned char D.42708;
  unsigned char D.42709;
  unsigned int D.42713;
  unsigned int D.42714;
  long int D.42715;
  struct MonoInst * D.42716;
  int D.42717;
  int D.42718;
  long int D.42722;
  struct MonoInst * D.42723;
  int D.42724;
  int D.42725;
  long int D.42729;
  struct MonoInst * D.42730;
  int D.42731;
  int D.42732;
  struct MonoInst * D.42736;
  int D.26949;
  int iftmp.364;
  int D.26948;
  const char[11] * D.42740;
  unsigned char D.42741;
  int D.42742;
  unsigned char D.42743;
  int D.42744;
  const unsigned char * D.42749;
  unsigned char D.42750;
  int D.42751;
  const unsigned char * D.42752;
  unsigned char D.42753;
  int D.42754;
  const unsigned char * D.42759;
  unsigned char D.42760;
  int D.42761;
  const unsigned char * D.42762;
  unsigned char D.42763;
  int D.42764;
  const unsigned char * D.42769;
  unsigned char D.42770;
  int D.42771;
  const unsigned char * D.42772;
  unsigned char D.42773;
  int D.42774;
  unsigned int D.42778;
  unsigned char D.42782;
  unsigned char D.42783;
  int D.26959;
  int iftmp.365;
  int D.26958;
  const char[16] * D.42787;
  unsigned char D.42788;
  int D.42789;
  unsigned char D.42790;
  int D.42791;
  const unsigned char * D.42796;
  unsigned char D.42797;
  int D.42798;
  const unsigned char * D.42799;
  unsigned char D.42800;
  int D.42801;
  const unsigned char * D.42806;
  unsigned char D.42807;
  int D.42808;
  const unsigned char * D.42809;
  unsigned char D.42810;
  int D.42811;
  const unsigned char * D.42816;
  unsigned char D.42817;
  int D.42818;
  const unsigned char * D.42819;
  unsigned char D.42820;
  int D.42821;
  unsigned int D.42825;
  unsigned int D.42826;
  long int D.42827;
  struct MonoInst * D.42828;
  int D.42829;
  int D.42830;
  long int D.42834;
  struct MonoInst * D.42835;
  int D.42836;
  int D.42837;
  long int D.42841;
  struct MonoInst * D.42842;
  int D.42843;
  int D.42844;
  struct MonoInst * * D.42845;
  struct MonoInst * D.42846;
  int D.42847;
  struct MonoClass * D.42851;
  int D.26973;
  int iftmp.366;
  int D.26972;
  const char[8] * D.42857;
  unsigned char D.42858;
  int D.42859;
  unsigned char D.42860;
  int D.42861;
  const unsigned char * D.42866;
  unsigned char D.42867;
  int D.42868;
  const unsigned char * D.42869;
  unsigned char D.42870;
  int D.42871;
  const unsigned char * D.42876;
  unsigned char D.42877;
  int D.42878;
  const unsigned char * D.42879;
  unsigned char D.42880;
  int D.42881;
  const unsigned char * D.42886;
  unsigned char D.42887;
  int D.42888;
  const unsigned char * D.42889;
  unsigned char D.42890;
  int D.42891;
  unsigned int D.42895;
  unsigned int D.42896;
  int D.42897;
  long int D.42902;
  struct MonoInst * D.42903;
  int D.42904;
  int D.42905;
  long int D.42909;
  struct MonoInst * D.42910;
  int D.42911;
  int D.42912;
  long int D.42917;
  struct MonoInst * D.42918;
  int D.42919;
  int D.42920;
  unsigned char D.42921;
  int D.26988;
  int iftmp.367;
  int D.26987;
  const char[20] * D.42932;
  unsigned char D.42933;
  int D.42934;
  unsigned char D.42935;
  int D.42936;
  const unsigned char * D.42941;
  unsigned char D.42942;
  int D.42943;
  const unsigned char * D.42944;
  unsigned char D.42945;
  int D.42946;
  const unsigned char * D.42951;
  unsigned char D.42952;
  int D.42953;
  const unsigned char * D.42954;
  unsigned char D.42955;
  int D.42956;
  const unsigned char * D.42961;
  unsigned char D.42962;
  int D.42963;
  const unsigned char * D.42964;
  unsigned char D.42965;
  int D.42966;
  int D.42969;
  unsigned int D.42971;
  unsigned int D.42972;
  long int D.42973;
  struct MonoInst * D.42974;
  int D.42975;
  int D.42976;
  int D.27000;
  int iftmp.368;
  int D.26999;
  const char[6] * D.42986;
  unsigned char D.42987;
  int D.42988;
  unsigned char D.42989;
  int D.42990;
  const unsigned char * D.42995;
  unsigned char D.42996;
  int D.42997;
  const unsigned char * D.42998;
  unsigned char D.42999;
  int D.43000;
  const unsigned char * D.43005;
  unsigned char D.43006;
  int D.43007;
  const unsigned char * D.43008;
  unsigned char D.43009;
  int D.43010;
  const unsigned char * D.43015;
  unsigned char D.43016;
  int D.43017;
  const unsigned char * D.43018;
  unsigned char D.43019;
  int D.43020;
  struct MonoClass * D.43027;
  int D.43030;
  int D.27009;
  int iftmp.369;
  int D.27008;
  const char[19] * D.43036;
  unsigned char D.43037;
  int D.43038;
  unsigned char D.43039;
  int D.43040;
  const unsigned char * D.43045;
  unsigned char D.43046;
  int D.43047;
  const unsigned char * D.43048;
  unsigned char D.43049;
  int D.43050;
  const unsigned char * D.43055;
  unsigned char D.43056;
  int D.43057;
  const unsigned char * D.43058;
  unsigned char D.43059;
  int D.43060;
  const unsigned char * D.43065;
  unsigned char D.43066;
  int D.43067;
  const unsigned char * D.43068;
  unsigned char D.43069;
  int D.43070;
  const char * D.43072;
  char D.43075;
  _Bool D.43076;
  int D.43077;
  int D.27018;
  int iftmp.370;
  int D.27017;
  const char[10] * D.43083;
  unsigned char D.43084;
  int D.43085;
  unsigned char D.43086;
  int D.43087;
  const unsigned char * D.43092;
  unsigned char D.43093;
  int D.43094;
  const unsigned char * D.43095;
  unsigned char D.43096;
  int D.43097;
  const unsigned char * D.43102;
  unsigned char D.43103;
  int D.43104;
  const unsigned char * D.43105;
  unsigned char D.43106;
  int D.43107;
  const unsigned char * D.43112;
  unsigned char D.43113;
  int D.43114;
  const unsigned char * D.43115;
  unsigned char D.43116;
  int D.43117;
  int D.27027;
  int iftmp.371;
  int D.27026;
  const char[14] * D.43123;
  unsigned char D.43124;
  int D.43125;
  unsigned char D.43126;
  int D.43127;
  const unsigned char * D.43132;
  unsigned char D.43133;
  int D.43134;
  const unsigned char * D.43135;
  unsigned char D.43136;
  int D.43137;
  const unsigned char * D.43142;
  unsigned char D.43143;
  int D.43144;
  const unsigned char * D.43145;
  unsigned char D.43146;
  int D.43147;
  const unsigned char * D.43152;
  unsigned char D.43153;
  int D.43154;
  const unsigned char * D.43155;
  unsigned char D.43156;
  int D.43157;
  short unsigned int D.43159;
  long int D.43162;
  unsigned int D.43165;
  unsigned int D.43166;
  int D.27041;
  int iftmp.372;
  int D.27040;
  unsigned char D.43170;
  int D.43171;
  const unsigned char * D.43176;
  unsigned char D.43177;
  int D.43178;
  const unsigned char * D.43183;
  unsigned char D.43184;
  int D.43185;
  const unsigned char * D.43190;
  unsigned char D.43191;
  int D.43192;
  _Bool D.43194;
  unsigned int D.43195;
  unsigned int D.43196;
  unsigned int D.43197;
  int D.43198;
  unsigned int D.43199;
  unsigned int D.43200;
  int D.43201;
  int D.43202;
  long int D.43207;
  struct MonoInst * D.43208;
  int D.43209;
  int D.43210;
  long int D.43214;
  struct MonoInst * D.43215;
  int D.43216;
  int D.43217;
  unsigned char D.43222;
  long int D.43226;
  struct MonoInst * D.43227;
  int D.43228;
  int D.43229;
  long int D.43233;
  struct MonoInst * D.43234;
  int D.43235;
  int D.43236;
  unsigned int D.43239;
  unsigned int D.43240;
  int D.43241;
  unsigned char * D.43245;
  struct MonoBasicBlock * * D.43248;
  long int D.43249;
  unsigned char * D.43250;
  long int D.43251;
  long int D.43252;
  long unsigned int D.43253;
  long unsigned int D.43254;
  struct MonoBasicBlock * * D.43255;
  unsigned int D.43256;
  short unsigned int D.43261;
  short unsigned int D.43262;
  short unsigned int D.43264;
  short unsigned int D.43266;
  struct MonoBasicBlock * * D.43267;
  struct MonoBasicBlock * * D.43268;
  struct MonoBasicBlock * D.43269;
  void * D.43279;
  struct MonoBasicBlock * * D.43280;
  struct MonoBasicBlock * * D.43281;
  long unsigned int D.43285;
  long unsigned int D.43286;
  unsigned int D.43289;
  unsigned int D.43290;
  int D.43291;
  long int D.43318;
  struct MonoInst * D.43319;
  int D.43320;
  int D.43321;
  unsigned int D.43324;
  unsigned int D.43325;
  int D.43326;
  unsigned char * D.43330;
  long int D.43333;
  long int D.43334;
  long unsigned int D.43335;
  long unsigned int D.43336;
  struct MonoBasicBlock * * D.43337;
  void * D.43353;
  struct MonoBasicBlock * * D.43354;
  struct MonoBasicBlock * * D.43355;
  unsigned int D.43361;
  unsigned int D.43362;
  int D.43363;
  unsigned char * D.43381;
  long int D.43384;
  long int D.43385;
  long unsigned int D.43386;
  long unsigned int D.43387;
  struct MonoBasicBlock * * D.43388;
  long int D.43409;
  struct MonoInst * D.43410;
  int D.43411;
  int D.43412;
  unsigned char * D.43416;
  long int D.43419;
  long int D.43420;
  long unsigned int D.43421;
  long unsigned int D.43422;
  struct MonoBasicBlock * * D.43423;
  int D.27059;
  int iftmp.373;
  int D.27058;
  const char[9] * D.43446;
  unsigned char D.43447;
  int D.43448;
  unsigned char D.43449;
  int D.43450;
  const unsigned char * D.43455;
  unsigned char D.43456;
  int D.43457;
  const unsigned char * D.43458;
  unsigned char D.43459;
  int D.43460;
  const unsigned char * D.43465;
  unsigned char D.43466;
  int D.43467;
  const unsigned char * D.43468;
  unsigned char D.43469;
  int D.43470;
  const unsigned char * D.43475;
  unsigned char D.43476;
  int D.43477;
  const unsigned char * D.43478;
  unsigned char D.43479;
  int D.43480;
  unsigned int D.43484;
  unsigned int D.43485;
  int D.43486;
  long int D.43491;
  struct MonoInst * D.43492;
  int D.43493;
  int D.43494;
  long int D.43498;
  struct MonoInst * D.43499;
  int D.43500;
  int D.43501;
  long int D.43506;
  struct MonoInst * D.43507;
  int D.43508;
  int D.43509;
  unsigned char D.43510;
  int D.27074;
  int iftmp.374;
  int D.27073;
  unsigned char D.43520;
  int D.43521;
  const unsigned char * D.43526;
  unsigned char D.43527;
  int D.43528;
  const unsigned char * D.43533;
  unsigned char D.43534;
  int D.43535;
  const unsigned char * D.43540;
  unsigned char D.43541;
  int D.43542;
  unsigned int D.43546;
  int D.43547;
  long int D.43552;
  struct MonoInst * D.43553;
  int D.43554;
  int D.43555;
  long int D.43559;
  struct MonoInst * D.43560;
  int D.43561;
  int D.43562;
  unsigned char D.43567;
  int D.27087;
  int iftmp.375;
  int D.27086;
  const char[23] * D.43576;
  unsigned char D.43577;
  int D.43578;
  unsigned char D.43579;
  int D.43580;
  const unsigned char * D.43585;
  unsigned char D.43586;
  int D.43587;
  const unsigned char * D.43588;
  unsigned char D.43589;
  int D.43590;
  const unsigned char * D.43595;
  unsigned char D.43596;
  int D.43597;
  const unsigned char * D.43598;
  unsigned char D.43599;
  int D.43600;
  const unsigned char * D.43605;
  unsigned char D.43606;
  int D.43607;
  const unsigned char * D.43608;
  unsigned char D.43609;
  int D.43610;
  unsigned int D.43614;
  int D.43615;
  struct MonoClass * D.43619;
  int D.27096;
  int iftmp.376;
  int D.27095;
  const char[13] * D.43625;
  unsigned char D.43626;
  int D.43627;
  unsigned char D.43628;
  int D.43629;
  const unsigned char * D.43634;
  unsigned char D.43635;
  int D.43636;
  const unsigned char * D.43637;
  unsigned char D.43638;
  int D.43639;
  const unsigned char * D.43644;
  unsigned char D.43645;
  int D.43646;
  const unsigned char * D.43647;
  unsigned char D.43648;
  int D.43649;
  const unsigned char * D.43654;
  unsigned char D.43655;
  int D.43656;
  const unsigned char * D.43657;
  unsigned char D.43658;
  int D.43659;
  int D.27105;
  int iftmp.377;
  int D.27104;
  const char[14] * D.43669;
  unsigned char D.43670;
  int D.43671;
  unsigned char D.43672;
  int D.43673;
  const unsigned char * D.43678;
  unsigned char D.43679;
  int D.43680;
  const unsigned char * D.43681;
  unsigned char D.43682;
  int D.43683;
  const unsigned char * D.43688;
  unsigned char D.43689;
  int D.43690;
  const unsigned char * D.43691;
  unsigned char D.43692;
  int D.43693;
  const unsigned char * D.43698;
  unsigned char D.43699;
  int D.43700;
  const unsigned char * D.43701;
  unsigned char D.43702;
  int D.43703;
  struct MonoClass * D.43708;
  int D.27114;
  int iftmp.378;
  int D.27113;
  const char[6] * D.43714;
  unsigned char D.43715;
  int D.43716;
  unsigned char D.43717;
  int D.43718;
  const unsigned char * D.43723;
  unsigned char D.43724;
  int D.43725;
  const unsigned char * D.43726;
  unsigned char D.43727;
  int D.43728;
  const unsigned char * D.43733;
  unsigned char D.43734;
  int D.43735;
  const unsigned char * D.43736;
  unsigned char D.43737;
  int D.43738;
  const unsigned char * D.43743;
  unsigned char D.43744;
  int D.43745;
  const unsigned char * D.43746;
  unsigned char D.43747;
  int D.43748;
  short unsigned int D.43752;
  struct MonoMethod * D.43755;
  long unsigned int D.43756;
  long unsigned int D.43757;
  int D.27124;
  int iftmp.379;
  int D.27123;
  const char[19] * D.43763;
  unsigned char D.43764;
  int D.43765;
  unsigned char D.43766;
  int D.43767;
  const unsigned char * D.43772;
  unsigned char D.43773;
  int D.43774;
  const unsigned char * D.43775;
  unsigned char D.43776;
  int D.43777;
  const unsigned char * D.43782;
  unsigned char D.43783;
  int D.43784;
  const unsigned char * D.43785;
  unsigned char D.43786;
  int D.43787;
  const unsigned char * D.43792;
  unsigned char D.43793;
  int D.43794;
  const unsigned char * D.43795;
  unsigned char D.43796;
  int D.43797;
  const char * D.43799;
  int D.27134;
  int iftmp.380;
  int D.27133;
  const char[17] * D.43811;
  unsigned char D.43812;
  int D.43813;
  unsigned char D.43814;
  int D.43815;
  const unsigned char * D.43820;
  unsigned char D.43821;
  int D.43822;
  const unsigned char * D.43823;
  unsigned char D.43824;
  int D.43825;
  const unsigned char * D.43830;
  unsigned char D.43831;
  int D.43832;
  const unsigned char * D.43833;
  unsigned char D.43834;
  int D.43835;
  const unsigned char * D.43840;
  unsigned char D.43841;
  int D.43842;
  const unsigned char * D.43843;
  unsigned char D.43844;
  int D.43845;
  int D.27143;
  int iftmp.381;
  int D.27142;
  const char[16] * D.43851;
  unsigned char D.43852;
  int D.43853;
  unsigned char D.43854;
  int D.43855;
  const unsigned char * D.43860;
  unsigned char D.43861;
  int D.43862;
  const unsigned char * D.43863;
  unsigned char D.43864;
  int D.43865;
  const unsigned char * D.43870;
  unsigned char D.43871;
  int D.43872;
  const unsigned char * D.43873;
  unsigned char D.43874;
  int D.43875;
  const unsigned char * D.43880;
  unsigned char D.43881;
  int D.43882;
  const unsigned char * D.43883;
  unsigned char D.43884;
  int D.43885;
  int D.27152;
  int iftmp.382;
  int D.27151;
  unsigned char D.43893;
  int D.43894;
  const unsigned char * D.43899;
  unsigned char D.43900;
  int D.43901;
  const unsigned char * D.43906;
  unsigned char D.43907;
  int D.43908;
  const unsigned char * D.43913;
  unsigned char D.43914;
  int D.43915;
  int D.27161;
  int iftmp.383;
  int D.27160;
  const char[5] * D.43921;
  unsigned char D.43922;
  int D.43923;
  unsigned char D.43924;
  int D.43925;
  const unsigned char * D.43930;
  unsigned char D.43931;
  int D.43932;
  const unsigned char * D.43933;
  unsigned char D.43934;
  int D.43935;
  const unsigned char * D.43940;
  unsigned char D.43941;
  int D.43942;
  const unsigned char * D.43943;
  unsigned char D.43944;
  int D.43945;
  const unsigned char * D.43950;
  unsigned char D.43951;
  int D.43952;
  const unsigned char * D.43953;
  unsigned char D.43954;
  int D.43955;
  struct MonoImage * D.43961;
  int D.27170;
  int iftmp.384;
  int D.27169;
  const char[17] * D.43966;
  unsigned char D.43967;
  int D.43968;
  unsigned char D.43969;
  int D.43970;
  const unsigned char * D.43975;
  unsigned char D.43976;
  int D.43977;
  const unsigned char * D.43978;
  unsigned char D.43979;
  int D.43980;
  const unsigned char * D.43985;
  unsigned char D.43986;
  int D.43987;
  const unsigned char * D.43988;
  unsigned char D.43989;
  int D.43990;
  const unsigned char * D.43995;
  unsigned char D.43996;
  int D.43997;
  const unsigned char * D.43998;
  unsigned char D.43999;
  int D.44000;
  const char * D.44002;
  int D.27179;
  int iftmp.385;
  int D.27178;
  const char[12] * D.44007;
  unsigned char D.44008;
  int D.44009;
  unsigned char D.44010;
  int D.44011;
  const unsigned char * D.44016;
  unsigned char D.44017;
  int D.44018;
  const unsigned char * D.44019;
  unsigned char D.44020;
  int D.44021;
  const unsigned char * D.44026;
  unsigned char D.44027;
  int D.44028;
  const unsigned char * D.44029;
  unsigned char D.44030;
  int D.44031;
  const unsigned char * D.44036;
  unsigned char D.44037;
  int D.44038;
  const unsigned char * D.44039;
  unsigned char D.44040;
  int D.44041;
  const char * D.44043;
  int D.27188;
  int iftmp.386;
  int D.27187;
  const char[5] * D.44048;
  unsigned char D.44049;
  int D.44050;
  unsigned char D.44051;
  int D.44052;
  const unsigned char * D.44057;
  unsigned char D.44058;
  int D.44059;
  const unsigned char * D.44060;
  unsigned char D.44061;
  int D.44062;
  const unsigned char * D.44067;
  unsigned char D.44068;
  int D.44069;
  const unsigned char * D.44070;
  unsigned char D.44071;
  int D.44072;
  const unsigned char * D.44077;
  unsigned char D.44078;
  int D.44079;
  const unsigned char * D.44080;
  unsigned char D.44081;
  int D.44082;
  struct MonoType * D.44086;
  unsigned char D.44087;
  unsigned int D.44090;
  int D.44091;
  int D.27197;
  int iftmp.387;
  int D.27196;
  const char[10] * D.44098;
  unsigned char D.44099;
  int D.44100;
  unsigned char D.44101;
  int D.44102;
  const unsigned char * D.44107;
  unsigned char D.44108;
  int D.44109;
  const unsigned char * D.44110;
  unsigned char D.44111;
  int D.44112;
  const unsigned char * D.44117;
  unsigned char D.44118;
  int D.44119;
  const unsigned char * D.44120;
  unsigned char D.44121;
  int D.44122;
  const unsigned char * D.44127;
  unsigned char D.44128;
  int D.44129;
  const unsigned char * D.44130;
  unsigned char D.44131;
  int D.44132;
  long int D.44143;
  struct MonoInst * D.44144;
  int D.44145;
  int D.44146;
  unsigned int D.44147;
  int D.44148;
  short unsigned int D.44152;
  unsigned int D.44153;
  int D.44154;
  int D.44155;
  guint8 iftmp.388;
  int D.27208;
  int iftmp.389;
  int D.27207;
  const char[10] * D.44167;
  unsigned char D.44168;
  int D.44169;
  unsigned char D.44170;
  int D.44171;
  const unsigned char * D.44176;
  unsigned char D.44177;
  int D.44178;
  const unsigned char * D.44179;
  unsigned char D.44180;
  int D.44181;
  const unsigned char * D.44186;
  unsigned char D.44187;
  int D.44188;
  const unsigned char * D.44189;
  unsigned char D.44190;
  int D.44191;
  const unsigned char * D.44196;
  unsigned char D.44197;
  int D.44198;
  const unsigned char * D.44199;
  unsigned char D.44200;
  int D.44201;
  long int D.44212;
  struct MonoInst * D.44213;
  int D.44214;
  int D.44215;
  unsigned int D.44216;
  int D.44217;
  short unsigned int D.44221;
  unsigned int D.44222;
  int D.44223;
  int D.44224;
  guint8 iftmp.390;
  int D.27219;
  int iftmp.391;
  int D.27218;
  const char[4] * D.44236;
  unsigned char D.44237;
  int D.44238;
  unsigned char D.44239;
  int D.44240;
  const unsigned char * D.44245;
  unsigned char D.44246;
  int D.44247;
  const unsigned char * D.44248;
  unsigned char D.44249;
  int D.44250;
  const unsigned char * D.44255;
  unsigned char D.44256;
  int D.44257;
  const unsigned char * D.44258;
  unsigned char D.44259;
  int D.44260;
  const unsigned char * D.44265;
  unsigned char D.44266;
  int D.44267;
  const unsigned char * D.44268;
  unsigned char D.44269;
  int D.44270;
  short unsigned int D.44281;
  unsigned int D.44282;
  int D.44283;
  guint8 iftmp.392;
  int D.27229;
  int iftmp.393;
  int D.27228;
  const char[16] * D.44294;
  unsigned char D.44295;
  int D.44296;
  unsigned char D.44297;
  int D.44298;
  const unsigned char * D.44303;
  unsigned char D.44304;
  int D.44305;
  const unsigned char * D.44306;
  unsigned char D.44307;
  int D.44308;
  const unsigned char * D.44313;
  unsigned char D.44314;
  int D.44315;
  const unsigned char * D.44316;
  unsigned char D.44317;
  int D.44318;
  const unsigned char * D.44323;
  unsigned char D.44324;
  int D.44325;
  const unsigned char * D.44326;
  unsigned char D.44327;
  int D.44328;
  struct MonoType * D.44332;
  unsigned char D.44333;
  gint32 iftmp.394;
  unsigned int D.44348;
  unsigned int D.44350;
  gint32 iftmp.395;
  unsigned int D.44360;
  unsigned int D.44362;
  long unsigned int D.44367;
  int D.27240;
  int iftmp.396;
  int D.27239;
  unsigned char D.44375;
  int D.44376;
  const unsigned char * D.44381;
  unsigned char D.44382;
  int D.44383;
  const unsigned char * D.44388;
  unsigned char D.44389;
  int D.44390;
  const unsigned char * D.44395;
  unsigned char D.44396;
  int D.44397;
  int D.27249;
  int iftmp.397;
  int D.27248;
  const char[6] * D.44410;
  unsigned char D.44411;
  int D.44412;
  unsigned char D.44413;
  int D.44414;
  const unsigned char * D.44419;
  unsigned char D.44420;
  int D.44421;
  const unsigned char * D.44422;
  unsigned char D.44423;
  int D.44424;
  const unsigned char * D.44429;
  unsigned char D.44430;
  int D.44431;
  const unsigned char * D.44432;
  unsigned char D.44433;
  int D.44434;
  const unsigned char * D.44439;
  unsigned char D.44440;
  int D.44441;
  const unsigned char * D.44442;
  unsigned char D.44443;
  int D.44444;
  int D.27258;
  int iftmp.398;
  int D.27257;
  const char[9] * D.44451;
  unsigned char D.44452;
  int D.44453;
  unsigned char D.44454;
  int D.44455;
  const unsigned char * D.44460;
  unsigned char D.44461;
  int D.44462;
  const unsigned char * D.44463;
  unsigned char D.44464;
  int D.44465;
  const unsigned char * D.44470;
  unsigned char D.44471;
  int D.44472;
  const unsigned char * D.44473;
  unsigned char D.44474;
  int D.44475;
  const unsigned char * D.44480;
  unsigned char D.44481;
  int D.44482;
  const unsigned char * D.44483;
  unsigned char D.44484;
  int D.44485;
  int D.44489;
  int D.27267;
  int iftmp.399;
  int D.27266;
  const char[23] * D.44501;
  unsigned char D.44502;
  int D.44503;
  unsigned char D.44504;
  int D.44505;
  const unsigned char * D.44510;
  unsigned char D.44511;
  int D.44512;
  const unsigned char * D.44513;
  unsigned char D.44514;
  int D.44515;
  const unsigned char * D.44520;
  unsigned char D.44521;
  int D.44522;
  const unsigned char * D.44523;
  unsigned char D.44524;
  int D.44525;
  const unsigned char * D.44530;
  unsigned char D.44531;
  int D.44532;
  const unsigned char * D.44533;
  unsigned char D.44534;
  int D.44535;
  int D.27276;
  int iftmp.400;
  int D.27275;
  const char[12] * D.44542;
  unsigned char D.44543;
  int D.44544;
  unsigned char D.44545;
  int D.44546;
  const unsigned char * D.44551;
  unsigned char D.44552;
  int D.44553;
  const unsigned char * D.44554;
  unsigned char D.44555;
  int D.44556;
  const unsigned char * D.44561;
  unsigned char D.44562;
  int D.44563;
  const unsigned char * D.44564;
  unsigned char D.44565;
  int D.44566;
  const unsigned char * D.44571;
  unsigned char D.44572;
  int D.44573;
  const unsigned char * D.44574;
  unsigned char D.44575;
  int D.44576;
  unsigned int D.44580;
  int D.44581;
  struct MonoClass * D.44586;
  int D.27285;
  int iftmp.401;
  int D.27284;
  struct MonoAssembly * D.44595;
  const char[8] * D.44596;
  unsigned char D.44597;
  int D.44598;
  unsigned char D.44599;
  int D.44600;
  const unsigned char * D.44605;
  unsigned char D.44606;
  int D.44607;
  const unsigned char * D.44608;
  unsigned char D.44609;
  int D.44610;
  const unsigned char * D.44615;
  unsigned char D.44616;
  int D.44617;
  const unsigned char * D.44618;
  unsigned char D.44619;
  int D.44620;
  const unsigned char * D.44625;
  unsigned char D.44626;
  int D.44627;
  const unsigned char * D.44628;
  unsigned char D.44629;
  int D.44630;
  const char * D.44632;
  int D.27294;
  int iftmp.402;
  int D.27293;
  const char[10] * D.44637;
  unsigned char D.44638;
  int D.44639;
  unsigned char D.44640;
  int D.44641;
  const unsigned char * D.44646;
  unsigned char D.44647;
  int D.44648;
  const unsigned char * D.44649;
  unsigned char D.44650;
  int D.44651;
  const unsigned char * D.44656;
  unsigned char D.44657;
  int D.44658;
  const unsigned char * D.44659;
  unsigned char D.44660;
  int D.44661;
  const unsigned char * D.44666;
  unsigned char D.44667;
  int D.44668;
  const unsigned char * D.44669;
  unsigned char D.44670;
  int D.44671;
  int D.27303;
  int iftmp.403;
  int D.27302;
  const char[9] * D.44676;
  unsigned char D.44677;
  int D.44678;
  unsigned char D.44679;
  int D.44680;
  const unsigned char * D.44685;
  unsigned char D.44686;
  int D.44687;
  const unsigned char * D.44688;
  unsigned char D.44689;
  int D.44690;
  const unsigned char * D.44695;
  unsigned char D.44696;
  int D.44697;
  const unsigned char * D.44698;
  unsigned char D.44699;
  int D.44700;
  const unsigned char * D.44705;
  unsigned char D.44706;
  int D.44707;
  const unsigned char * D.44708;
  unsigned char D.44709;
  int D.44710;
  int D.27312;
  int iftmp.404;
  int D.27311;
  const char[10] * D.44717;
  unsigned char D.44718;
  int D.44719;
  unsigned char D.44720;
  int D.44721;
  const unsigned char * D.44726;
  unsigned char D.44727;
  int D.44728;
  const unsigned char * D.44729;
  unsigned char D.44730;
  int D.44731;
  const unsigned char * D.44736;
  unsigned char D.44737;
  int D.44738;
  const unsigned char * D.44739;
  unsigned char D.44740;
  int D.44741;
  const unsigned char * D.44746;
  unsigned char D.44747;
  int D.44748;
  const unsigned char * D.44749;
  unsigned char D.44750;
  int D.44751;
  long unsigned int D.44755;
  short unsigned int D.44758;
  struct MonoInst * ins;
  static struct MonoClass * runtime_helpers_class = 0B;

  ins = 0B;
  runtime_helpers_class.361 = runtime_helpers_class;
  if (runtime_helpers_class.361 == 0B) goto <D.42456>; else goto <D.42457>;
  <D.42456>:
  D.42458 = mono_defaults.corlib;
  runtime_helpers_class.362 = mono_class_from_name (D.42458, "System.Runtime.CompilerServices", "RuntimeHelpers");
  runtime_helpers_class = runtime_helpers_class.362;
  <D.42457>:
  D.42460 = cmethod->klass;
  D.42461 = mono_defaults.string_class;
  if (D.42460 == D.42461) goto <D.42462>; else goto <D.42463>;
  <D.42462>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.42465>; else goto <D.42466>;
    <D.42465>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42467 = "get_Chars";
      D.42468 = MEM[(const unsigned char *)D.42467];
      D.42469 = (int) D.42468;
      D.42470 = *__s2;
      D.42471 = (int) D.42470;
      __result = D.42469 - D.42471;
      {
        if (__s2_len != 0) goto <D.42472>; else goto <D.42473>;
        <D.42472>:
        if (__result == 0) goto <D.42474>; else goto <D.42475>;
        <D.42474>:
        D.42476 = &MEM[(void *)"get_Chars" + 1B];
        D.42477 = *D.42476;
        D.42478 = (int) D.42477;
        D.42479 = __s2 + 1;
        D.42480 = *D.42479;
        D.42481 = (int) D.42480;
        __result = D.42478 - D.42481;
        if (__s2_len > 1) goto <D.42482>; else goto <D.42483>;
        <D.42482>:
        if (__result == 0) goto <D.42484>; else goto <D.42485>;
        <D.42484>:
        D.42486 = &MEM[(void *)"get_Chars" + 2B];
        D.42487 = *D.42486;
        D.42488 = (int) D.42487;
        D.42489 = __s2 + 2;
        D.42490 = *D.42489;
        D.42491 = (int) D.42490;
        __result = D.42488 - D.42491;
        if (__s2_len > 2) goto <D.42492>; else goto <D.42493>;
        <D.42492>:
        if (__result == 0) goto <D.42494>; else goto <D.42495>;
        <D.42494>:
        D.42496 = &MEM[(void *)"get_Chars" + 3B];
        D.42497 = *D.42496;
        D.42498 = (int) D.42497;
        D.42499 = __s2 + 3;
        D.42500 = *D.42499;
        D.42501 = (int) D.42500;
        __result = D.42498 - D.42501;
        <D.42495>:
        <D.42493>:
        <D.42485>:
        <D.42483>:
        <D.42475>:
        <D.42473>:
      }
      D.26907 = __result;
    }
    iftmp.363 = -D.26907;
    goto <D.42502>;
    <D.42466>:
    D.42503 = cmethod->name;
    iftmp.363 = __builtin_strcmp (D.42503, "get_Chars");
    <D.42502>:
    D.26908 = iftmp.363;
  }
  if (D.26908 == 0) goto <D.42504>; else goto <D.42505>;
  <D.42504>:
  {
    int dreg;
    int index_reg;
    int mult_reg;
    int add_reg;

    D.42506 = alloc_ireg (cfg);
    dreg = (int) D.42506;
    D.42507 = alloc_preg (cfg);
    index_reg = (int) D.42507;
    D.42508 = alloc_preg (cfg);
    mult_reg = (int) D.42508;
    D.42509 = alloc_preg (cfg);
    add_reg = (int) D.42509;
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42511 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42511;
      inst->prev = 0B;
      D.42512 = inst->prev;
      inst->next = D.42512;
      inst->opcode = 762;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42513 = inst->sreg3;
      inst->sreg2 = D.42513;
      D.42514 = inst->sreg2;
      inst->sreg1 = D.42514;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = index_reg;
      D.42516 = args + 8;
      D.42517 = *D.42516;
      D.42518 = D.42517->dreg;
      inst->sreg1 = D.42518;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42521>; else goto <D.42522>;
      <D.42521>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42523>;
      <D.42522>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42523>:
    }
    D.42524 = cfg->opt;
    D.42525 = D.42524 & 134217728;
    if (D.42525 == 0) goto <D.42526>; else goto <D.42527>;
    <D.42526>:
    D.42524 = cfg->opt;
    D.42528 = D.42524 & 262144;
    if (D.42528 == 0) goto <D.42529>; else goto <D.42530>;
    <D.42529>:
    D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.42532 = D.42531 & 64;
    if (D.42532 != 0) goto <D.42533>; else goto <D.42534>;
    <D.42533>:
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42535 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42535;
      inst->prev = 0B;
      D.42536 = inst->prev;
      inst->next = D.42536;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42537 = inst->sreg3;
      inst->sreg2 = D.42537;
      D.42538 = inst->sreg2;
      inst->sreg1 = D.42538;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = -1;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg1 = D.42540;
      inst->data.op[1].const_val = 0;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42541>; else goto <D.42542>;
      <D.42541>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42543>;
      <D.42542>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42543>:
    }
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42544 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42544;
      inst->prev = 0B;
      D.42545 = inst->prev;
      inst->next = D.42545;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42546 = inst->sreg3;
      inst->sreg2 = D.42546;
      D.42547 = inst->sreg2;
      inst->sreg1 = D.42547;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->data.op[1].p = "NullReferenceException";
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42548>; else goto <D.42549>;
      <D.42548>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42550>;
      <D.42549>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42550>:
    }
    goto <D.42551>;
    <D.42534>:
    <D.42551>:
    if (0 != 0) goto <D.42552>; else goto <D.42553>;
    <D.42552>:
    {
      int _length_reg;

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

        __ins_flags = 32;
        D.42557 = __ins_flags & 32;
        if (D.42557 != 0) goto <D.42558>; else goto <D.42559>;
        <D.42558>:
        D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.42532 = D.42531 & 64;
        if (D.42532 != 0) goto <D.42560>; else goto <D.42561>;
        <D.42560>:
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42562 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42562;
          inst->prev = 0B;
          D.42563 = inst->prev;
          inst->next = D.42563;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42564 = inst->sreg3;
          inst->sreg2 = D.42564;
          D.42565 = inst->sreg2;
          inst->sreg1 = D.42565;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->dreg = -1;
          D.42539 = *args;
          D.42540 = D.42539->dreg;
          inst->sreg1 = D.42540;
          inst->data.op[1].const_val = 0;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42566>; else goto <D.42567>;
          <D.42566>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42568>;
          <D.42567>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42568>:
        }
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42569 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42569;
          inst->prev = 0B;
          D.42570 = inst->prev;
          inst->next = D.42570;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42571 = inst->sreg3;
          inst->sreg2 = D.42571;
          D.42572 = inst->sreg2;
          inst->sreg1 = D.42572;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->data.op[1].p = "NullReferenceException";
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42573>; else goto <D.42574>;
          <D.42573>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42575>;
          <D.42574>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42575>:
        }
        goto <D.42576>;
        <D.42561>:
        <D.42576>:
        <D.42559>:
        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42577 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42577;
        inst->prev = 0B;
        D.42578 = inst->prev;
        inst->next = D.42578;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42579 = inst->sreg3;
        inst->sreg2 = D.42579;
        D.42580 = inst->sreg2;
        inst->sreg1 = D.42580;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = _length_reg;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.42581 = (unsigned char) __ins_flags;
        inst->flags = D.42581;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42582>; else goto <D.42583>;
        <D.42582>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42584>;
        <D.42583>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42584>:
      }
      goto <D.42585>;
      <D.42556>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 64;
        D.42586 = __ins_flags & 32;
        if (D.42586 != 0) goto <D.42587>; else goto <D.42588>;
        <D.42587>:
        D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.42532 = D.42531 & 64;
        if (D.42532 != 0) goto <D.42589>; else goto <D.42590>;
        <D.42589>:
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42591 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42591;
          inst->prev = 0B;
          D.42592 = inst->prev;
          inst->next = D.42592;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42593 = inst->sreg3;
          inst->sreg2 = D.42593;
          D.42594 = inst->sreg2;
          inst->sreg1 = D.42594;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->dreg = -1;
          D.42539 = *args;
          D.42540 = D.42539->dreg;
          inst->sreg1 = D.42540;
          inst->data.op[1].const_val = 0;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42595>; else goto <D.42596>;
          <D.42595>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42597>;
          <D.42596>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42597>:
        }
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42598 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42598;
          inst->prev = 0B;
          D.42599 = inst->prev;
          inst->next = D.42599;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42600 = inst->sreg3;
          inst->sreg2 = D.42600;
          D.42601 = inst->sreg2;
          inst->sreg1 = D.42601;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->data.op[1].p = "NullReferenceException";
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42602>; else goto <D.42603>;
          <D.42602>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42604>;
          <D.42603>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42604>:
        }
        goto <D.42605>;
        <D.42590>:
        <D.42605>:
        <D.42588>:
        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42606 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42606;
        inst->prev = 0B;
        D.42607 = inst->prev;
        inst->next = D.42607;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42608 = inst->sreg3;
        inst->sreg2 = D.42608;
        D.42609 = inst->sreg2;
        inst->sreg1 = D.42609;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = _length_reg;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.42610 = (unsigned char) __ins_flags;
        inst->flags = D.42610;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42611>; else goto <D.42612>;
        <D.42611>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42613>;
        <D.42612>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42613>:
      }
      <D.42585>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42614 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42614;
        inst->prev = 0B;
        D.42615 = inst->prev;
        inst->next = D.42615;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42616 = inst->sreg3;
        inst->sreg2 = D.42616;
        D.42617 = inst->sreg2;
        inst->sreg1 = D.42617;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        inst->sreg1 = _length_reg;
        inst->sreg2 = index_reg;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42618>; else goto <D.42619>;
        <D.42618>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42620>;
        <D.42619>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42620>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42621 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42621;
        inst->prev = 0B;
        D.42622 = inst->prev;
        inst->next = D.42622;
        inst->opcode = 459;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42623 = inst->sreg3;
        inst->sreg2 = D.42623;
        D.42624 = inst->sreg2;
        inst->sreg1 = D.42624;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "IndexOutOfRangeException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42625>; else goto <D.42626>;
        <D.42625>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42627>;
        <D.42626>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42627>:
      }
    }
    goto <D.42628>;
    <D.42553>:
    {
      int _length_reg;

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

        __ins_flags = 32;
        D.42632 = __ins_flags & 32;
        if (D.42632 != 0) goto <D.42633>; else goto <D.42634>;
        <D.42633>:
        D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.42532 = D.42531 & 64;
        if (D.42532 != 0) goto <D.42635>; else goto <D.42636>;
        <D.42635>:
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42637 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42637;
          inst->prev = 0B;
          D.42638 = inst->prev;
          inst->next = D.42638;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42639 = inst->sreg3;
          inst->sreg2 = D.42639;
          D.42640 = inst->sreg2;
          inst->sreg1 = D.42640;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->dreg = -1;
          D.42539 = *args;
          D.42540 = D.42539->dreg;
          inst->sreg1 = D.42540;
          inst->data.op[1].const_val = 0;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42641>; else goto <D.42642>;
          <D.42641>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42643>;
          <D.42642>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42643>:
        }
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42644 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42644;
          inst->prev = 0B;
          D.42645 = inst->prev;
          inst->next = D.42645;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42646 = inst->sreg3;
          inst->sreg2 = D.42646;
          D.42647 = inst->sreg2;
          inst->sreg1 = D.42647;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->data.op[1].p = "NullReferenceException";
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42648>; else goto <D.42649>;
          <D.42648>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42650>;
          <D.42649>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42650>:
        }
        goto <D.42651>;
        <D.42636>:
        <D.42651>:
        <D.42634>:
        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42652 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42652;
        inst->prev = 0B;
        D.42653 = inst->prev;
        inst->next = D.42653;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42654 = inst->sreg3;
        inst->sreg2 = D.42654;
        D.42655 = inst->sreg2;
        inst->sreg1 = D.42655;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = _length_reg;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.42656 = (unsigned char) __ins_flags;
        inst->flags = D.42656;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42657>; else goto <D.42658>;
        <D.42657>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42659>;
        <D.42658>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42659>:
      }
      goto <D.42660>;
      <D.42631>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 64;
        D.42661 = __ins_flags & 32;
        if (D.42661 != 0) goto <D.42662>; else goto <D.42663>;
        <D.42662>:
        D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.42532 = D.42531 & 64;
        if (D.42532 != 0) goto <D.42664>; else goto <D.42665>;
        <D.42664>:
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42666 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42666;
          inst->prev = 0B;
          D.42667 = inst->prev;
          inst->next = D.42667;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42668 = inst->sreg3;
          inst->sreg2 = D.42668;
          D.42669 = inst->sreg2;
          inst->sreg1 = D.42669;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->dreg = -1;
          D.42539 = *args;
          D.42540 = D.42539->dreg;
          inst->sreg1 = D.42540;
          inst->data.op[1].const_val = 0;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42670>; else goto <D.42671>;
          <D.42670>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42672>;
          <D.42671>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42672>:
        }
        {
          struct MonoInst * inst;

          D.42510 = cfg->mempool;
          inst = mono_mempool_alloc (D.42510, 80);
          inst->data.op[1].const_val = 0;
          D.42673 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.42673;
          inst->prev = 0B;
          D.42674 = inst->prev;
          inst->next = D.42674;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.42675 = inst->sreg3;
          inst->sreg2 = D.42675;
          D.42676 = inst->sreg2;
          inst->sreg1 = D.42676;
          D.42515 = cfg->ip;
          inst->cil_code = D.42515;
          inst->data.op[1].p = "NullReferenceException";
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          if (D.42520 != 0B) goto <D.42677>; else goto <D.42678>;
          <D.42677>:
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          D.42520->next = inst;
          D.42519 = cfg->cbb;
          D.42520 = D.42519->last_ins;
          inst->prev = D.42520;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          goto <D.42679>;
          <D.42678>:
          D.42519 = cfg->cbb;
          D.42519 = cfg->cbb;
          D.42519->last_ins = inst;
          D.42520 = D.42519->last_ins;
          D.42519->code = D.42520;
          <D.42679>:
        }
        goto <D.42680>;
        <D.42665>:
        <D.42680>:
        <D.42663>:
        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42681 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42681;
        inst->prev = 0B;
        D.42682 = inst->prev;
        inst->next = D.42682;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42683 = inst->sreg3;
        inst->sreg2 = D.42683;
        D.42684 = inst->sreg2;
        inst->sreg1 = D.42684;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = _length_reg;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.42685 = (unsigned char) __ins_flags;
        inst->flags = D.42685;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42686>; else goto <D.42687>;
        <D.42686>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42688>;
        <D.42687>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42688>:
      }
      <D.42660>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42689 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42689;
        inst->prev = 0B;
        D.42690 = inst->prev;
        inst->next = D.42690;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42691 = inst->sreg3;
        inst->sreg2 = D.42691;
        D.42692 = inst->sreg2;
        inst->sreg1 = D.42692;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        inst->sreg1 = _length_reg;
        inst->sreg2 = index_reg;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42693>; else goto <D.42694>;
        <D.42693>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42695>;
        <D.42694>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42695>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42696 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42696;
        inst->prev = 0B;
        D.42697 = inst->prev;
        inst->next = D.42697;
        inst->opcode = 459;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42698 = inst->sreg3;
        inst->sreg2 = D.42698;
        D.42699 = inst->sreg2;
        inst->sreg1 = D.42699;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "IndexOutOfRangeException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42700>; else goto <D.42701>;
        <D.42700>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42702>;
        <D.42701>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42702>:
      }
    }
    <D.42628>:
    goto <D.42703>;
    <D.42530>:
    {
      struct MonoInst * ins;

      D.42510 = cfg->mempool;
      ins = mono_mempool_alloc (D.42510, 80);
      ins->data.op[1].const_val = 0;
      D.42704 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.42704;
      ins->prev = 0B;
      D.42705 = ins->prev;
      ins->next = D.42705;
      ins->opcode = 784;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.42706 = ins->sreg3;
      ins->sreg2 = D.42706;
      D.42707 = ins->sreg2;
      ins->sreg1 = D.42707;
      D.42515 = cfg->ip;
      ins->cil_code = D.42515;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      ins->sreg1 = D.42540;
      ins->sreg2 = index_reg;
      ins->data.op[1].const_val = 16;
      D.42708 = ins->flags;
      D.42709 = D.42708 | 32;
      ins->flags = D.42709;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42710>; else goto <D.42711>;
      <D.42710>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = ins;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      ins->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      goto <D.42712>;
      <D.42711>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42712>:
      D.42713 = cfg->flags;
      D.42714 = D.42713 | 256;
      cfg->flags = D.42714;
      D.42519 = cfg->cbb;
      D.42519->has_array_access = 1;
    }
    <D.42703>:
    <D.42527>:
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42715 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42715;
      inst->prev = 0B;
      D.42716 = inst->prev;
      inst->next = D.42716;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42717 = inst->sreg3;
      inst->sreg2 = D.42717;
      D.42718 = inst->sreg2;
      inst->sreg1 = D.42718;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = mult_reg;
      inst->sreg1 = index_reg;
      inst->data.op[1].const_val = 1;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42719>; else goto <D.42720>;
      <D.42719>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42721>;
      <D.42720>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42721>:
    }
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 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 = 479;
      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.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = add_reg;
      inst->sreg1 = mult_reg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg2 = D.42540;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42726>; else goto <D.42727>;
      <D.42726>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42728>;
      <D.42727>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42728>:
    }
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 392;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = add_reg;
    ins->data.op[0].const_val = 20;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.42733>; else goto <D.42734>;
    <D.42733>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.42735>;
    <D.42734>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.42735>:
    type_from_op (ins, 0B, 0B);
    D.42736 = ins;
    return D.42736;
  }
  <D.42505>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.42738>; else goto <D.42739>;
    <D.42738>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42740 = "get_Length";
      D.42741 = MEM[(const unsigned char *)D.42740];
      D.42742 = (int) D.42741;
      D.42743 = *__s2;
      D.42744 = (int) D.42743;
      __result = D.42742 - D.42744;
      {
        if (__s2_len != 0) goto <D.42745>; else goto <D.42746>;
        <D.42745>:
        if (__result == 0) goto <D.42747>; else goto <D.42748>;
        <D.42747>:
        D.42749 = &MEM[(void *)"get_Length" + 1B];
        D.42750 = *D.42749;
        D.42751 = (int) D.42750;
        D.42752 = __s2 + 1;
        D.42753 = *D.42752;
        D.42754 = (int) D.42753;
        __result = D.42751 - D.42754;
        if (__s2_len > 1) goto <D.42755>; else goto <D.42756>;
        <D.42755>:
        if (__result == 0) goto <D.42757>; else goto <D.42758>;
        <D.42757>:
        D.42759 = &MEM[(void *)"get_Length" + 2B];
        D.42760 = *D.42759;
        D.42761 = (int) D.42760;
        D.42762 = __s2 + 2;
        D.42763 = *D.42762;
        D.42764 = (int) D.42763;
        __result = D.42761 - D.42764;
        if (__s2_len > 2) goto <D.42765>; else goto <D.42766>;
        <D.42765>:
        if (__result == 0) goto <D.42767>; else goto <D.42768>;
        <D.42767>:
        D.42769 = &MEM[(void *)"get_Length" + 3B];
        D.42770 = *D.42769;
        D.42771 = (int) D.42770;
        D.42772 = __s2 + 3;
        D.42773 = *D.42772;
        D.42774 = (int) D.42773;
        __result = D.42771 - D.42774;
        <D.42768>:
        <D.42766>:
        <D.42758>:
        <D.42756>:
        <D.42748>:
        <D.42746>:
      }
      D.26948 = __result;
    }
    iftmp.364 = -D.26948;
    goto <D.42775>;
    <D.42739>:
    D.42503 = cmethod->name;
    iftmp.364 = __builtin_strcmp (D.42503, "get_Length");
    <D.42775>:
    D.26949 = iftmp.364;
  }
  if (D.26949 == 0) goto <D.42776>; else goto <D.42777>;
  <D.42776>:
  {
    int dreg;

    D.42778 = alloc_ireg (cfg);
    dreg = (int) D.42778;
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 781;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.42779>; else goto <D.42780>;
    <D.42779>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.42781>;
    <D.42780>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.42781>:
    ins->type = 1;
    D.42782 = ins->flags;
    D.42783 = D.42782 | 32;
    ins->flags = D.42783;
    D.42519 = cfg->cbb;
    D.42519->has_array_access = 1;
    D.42713 = cfg->flags;
    D.42714 = D.42713 | 256;
    cfg->flags = D.42714;
    D.42736 = ins;
    return D.42736;
  }
  <D.42777>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 15;
    if (__s2_len <= 3) goto <D.42785>; else goto <D.42786>;
    <D.42785>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42787 = "InternalSetChar";
      D.42788 = MEM[(const unsigned char *)D.42787];
      D.42789 = (int) D.42788;
      D.42790 = *__s2;
      D.42791 = (int) D.42790;
      __result = D.42789 - D.42791;
      {
        if (__s2_len != 0) goto <D.42792>; else goto <D.42793>;
        <D.42792>:
        if (__result == 0) goto <D.42794>; else goto <D.42795>;
        <D.42794>:
        D.42796 = &MEM[(void *)"InternalSetChar" + 1B];
        D.42797 = *D.42796;
        D.42798 = (int) D.42797;
        D.42799 = __s2 + 1;
        D.42800 = *D.42799;
        D.42801 = (int) D.42800;
        __result = D.42798 - D.42801;
        if (__s2_len > 1) goto <D.42802>; else goto <D.42803>;
        <D.42802>:
        if (__result == 0) goto <D.42804>; else goto <D.42805>;
        <D.42804>:
        D.42806 = &MEM[(void *)"InternalSetChar" + 2B];
        D.42807 = *D.42806;
        D.42808 = (int) D.42807;
        D.42809 = __s2 + 2;
        D.42810 = *D.42809;
        D.42811 = (int) D.42810;
        __result = D.42808 - D.42811;
        if (__s2_len > 2) goto <D.42812>; else goto <D.42813>;
        <D.42812>:
        if (__result == 0) goto <D.42814>; else goto <D.42815>;
        <D.42814>:
        D.42816 = &MEM[(void *)"InternalSetChar" + 3B];
        D.42817 = *D.42816;
        D.42818 = (int) D.42817;
        D.42819 = __s2 + 3;
        D.42820 = *D.42819;
        D.42821 = (int) D.42820;
        __result = D.42818 - D.42821;
        <D.42815>:
        <D.42813>:
        <D.42805>:
        <D.42803>:
        <D.42795>:
        <D.42793>:
      }
      D.26958 = __result;
    }
    iftmp.365 = -D.26958;
    goto <D.42822>;
    <D.42786>:
    D.42503 = cmethod->name;
    iftmp.365 = __builtin_strcmp (D.42503, "InternalSetChar");
    <D.42822>:
    D.26959 = iftmp.365;
  }
  if (D.26959 == 0) goto <D.42823>; else goto <D.42824>;
  <D.42823>:
  {
    int mult_reg;
    int add_reg;

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

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42827 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42827;
      inst->prev = 0B;
      D.42828 = inst->prev;
      inst->next = D.42828;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42829 = inst->sreg3;
      inst->sreg2 = D.42829;
      D.42830 = inst->sreg2;
      inst->sreg1 = D.42830;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = mult_reg;
      D.42516 = args + 8;
      D.42517 = *D.42516;
      D.42518 = D.42517->dreg;
      inst->sreg1 = D.42518;
      inst->data.op[1].const_val = 1;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42831>; else goto <D.42832>;
      <D.42831>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42833>;
      <D.42832>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42833>:
    }
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42834 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42834;
      inst->prev = 0B;
      D.42835 = inst->prev;
      inst->next = D.42835;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42836 = inst->sreg3;
      inst->sreg2 = D.42836;
      D.42837 = inst->sreg2;
      inst->sreg1 = D.42837;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = add_reg;
      inst->sreg1 = mult_reg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg2 = D.42540;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42838>; else goto <D.42839>;
      <D.42838>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42840>;
      <D.42839>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42840>:
    }
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42841 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42841;
      inst->prev = 0B;
      D.42842 = inst->prev;
      inst->next = D.42842;
      inst->opcode = 376;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42843 = inst->sreg3;
      inst->sreg2 = D.42843;
      D.42844 = inst->sreg2;
      inst->sreg1 = D.42844;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      D.42845 = args + 16;
      D.42846 = *D.42845;
      D.42847 = D.42846->dreg;
      inst->sreg1 = D.42847;
      inst->dreg = add_reg;
      inst->data.op[0].const_val = 20;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42848>; else goto <D.42849>;
      <D.42848>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42850>;
      <D.42849>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42850>:
    }
    D.42519 = cfg->cbb;
    D.42736 = D.42519->last_ins;
    return D.42736;
  }
  <D.42824>:
  D.42736 = 0B;
  return D.42736;
  <D.42463>:
  D.42460 = cmethod->klass;
  D.42851 = mono_defaults.object_class;
  if (D.42460 == D.42851) goto <D.42852>; else goto <D.42853>;
  <D.42852>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.42857 = "GetType";
      D.42858 = MEM[(const unsigned char *)D.42857];
      D.42859 = (int) D.42858;
      D.42860 = *__s2;
      D.42861 = (int) D.42860;
      __result = D.42859 - D.42861;
      {
        if (__s2_len != 0) goto <D.42862>; else goto <D.42863>;
        <D.42862>:
        if (__result == 0) goto <D.42864>; else goto <D.42865>;
        <D.42864>:
        D.42866 = &MEM[(void *)"GetType" + 1B];
        D.42867 = *D.42866;
        D.42868 = (int) D.42867;
        D.42869 = __s2 + 1;
        D.42870 = *D.42869;
        D.42871 = (int) D.42870;
        __result = D.42868 - D.42871;
        if (__s2_len > 1) goto <D.42872>; else goto <D.42873>;
        <D.42872>:
        if (__result == 0) goto <D.42874>; else goto <D.42875>;
        <D.42874>:
        D.42876 = &MEM[(void *)"GetType" + 2B];
        D.42877 = *D.42876;
        D.42878 = (int) D.42877;
        D.42879 = __s2 + 2;
        D.42880 = *D.42879;
        D.42881 = (int) D.42880;
        __result = D.42878 - D.42881;
        if (__s2_len > 2) goto <D.42882>; else goto <D.42883>;
        <D.42882>:
        if (__result == 0) goto <D.42884>; else goto <D.42885>;
        <D.42884>:
        D.42886 = &MEM[(void *)"GetType" + 3B];
        D.42887 = *D.42886;
        D.42888 = (int) D.42887;
        D.42889 = __s2 + 3;
        D.42890 = *D.42889;
        D.42891 = (int) D.42890;
        __result = D.42888 - D.42891;
        <D.42885>:
        <D.42883>:
        <D.42875>:
        <D.42873>:
        <D.42865>:
        <D.42863>:
      }
      D.26972 = __result;
    }
    iftmp.366 = -D.26972;
    goto <D.42892>;
    <D.42856>:
    D.42503 = cmethod->name;
    iftmp.366 = __builtin_strcmp (D.42503, "GetType");
    <D.42892>:
    D.26973 = iftmp.366;
  }
  if (D.26973 == 0) goto <D.42893>; else goto <D.42894>;
  <D.42893>:
  {
    int dreg;
    int vt_reg;

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

      __ins_flags = 32;
      D.42897 = __ins_flags & 32;
      if (D.42897 != 0) goto <D.42898>; else goto <D.42899>;
      <D.42898>:
      D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.42532 = D.42531 & 64;
      if (D.42532 != 0) goto <D.42900>; else goto <D.42901>;
      <D.42900>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42902 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42902;
        inst->prev = 0B;
        D.42903 = inst->prev;
        inst->next = D.42903;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42904 = inst->sreg3;
        inst->sreg2 = D.42904;
        D.42905 = inst->sreg2;
        inst->sreg1 = D.42905;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[1].const_val = 0;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42906>; else goto <D.42907>;
        <D.42906>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42908>;
        <D.42907>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42908>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.42909 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.42909;
        inst->prev = 0B;
        D.42910 = inst->prev;
        inst->next = D.42910;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.42911 = inst->sreg3;
        inst->sreg2 = D.42911;
        D.42912 = inst->sreg2;
        inst->sreg1 = D.42912;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "NullReferenceException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.42913>; else goto <D.42914>;
        <D.42913>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.42915>;
        <D.42914>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.42915>:
      }
      goto <D.42916>;
      <D.42901>:
      <D.42916>:
      <D.42899>:
      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42917 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42917;
      inst->prev = 0B;
      D.42918 = inst->prev;
      inst->next = D.42918;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42919 = inst->sreg3;
      inst->sreg2 = D.42919;
      D.42920 = inst->sreg2;
      inst->sreg1 = D.42920;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = vt_reg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg1 = D.42540;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.42921 = (unsigned char) __ins_flags;
      inst->flags = D.42921;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42922>; else goto <D.42923>;
      <D.42922>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42924>;
      <D.42923>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42924>:
    }
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 388;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = vt_reg;
    ins->data.op[0].const_val = 24;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.42925>; else goto <D.42926>;
    <D.42925>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.42927>;
    <D.42926>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.42927>:
    type_from_op (ins, 0B, 0B);
    D.42736 = ins;
    return D.42736;
  }
  <D.42894>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 19;
    if (__s2_len <= 3) goto <D.42930>; else goto <D.42931>;
    <D.42930>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42932 = "InternalGetHashCode";
      D.42933 = MEM[(const unsigned char *)D.42932];
      D.42934 = (int) D.42933;
      D.42935 = *__s2;
      D.42936 = (int) D.42935;
      __result = D.42934 - D.42936;
      {
        if (__s2_len != 0) goto <D.42937>; else goto <D.42938>;
        <D.42937>:
        if (__result == 0) goto <D.42939>; else goto <D.42940>;
        <D.42939>:
        D.42941 = &MEM[(void *)"InternalGetHashCode" + 1B];
        D.42942 = *D.42941;
        D.42943 = (int) D.42942;
        D.42944 = __s2 + 1;
        D.42945 = *D.42944;
        D.42946 = (int) D.42945;
        __result = D.42943 - D.42946;
        if (__s2_len > 1) goto <D.42947>; else goto <D.42948>;
        <D.42947>:
        if (__result == 0) goto <D.42949>; else goto <D.42950>;
        <D.42949>:
        D.42951 = &MEM[(void *)"InternalGetHashCode" + 2B];
        D.42952 = *D.42951;
        D.42953 = (int) D.42952;
        D.42954 = __s2 + 2;
        D.42955 = *D.42954;
        D.42956 = (int) D.42955;
        __result = D.42953 - D.42956;
        if (__s2_len > 2) goto <D.42957>; else goto <D.42958>;
        <D.42957>:
        if (__result == 0) goto <D.42959>; else goto <D.42960>;
        <D.42959>:
        D.42961 = &MEM[(void *)"InternalGetHashCode" + 3B];
        D.42962 = *D.42961;
        D.42963 = (int) D.42962;
        D.42964 = __s2 + 3;
        D.42965 = *D.42964;
        D.42966 = (int) D.42965;
        __result = D.42963 - D.42966;
        <D.42960>:
        <D.42958>:
        <D.42950>:
        <D.42948>:
        <D.42940>:
        <D.42938>:
      }
      D.26987 = __result;
    }
    iftmp.367 = -D.26987;
    goto <D.42967>;
    <D.42931>:
    D.42503 = cmethod->name;
    iftmp.367 = __builtin_strcmp (D.42503, "InternalGetHashCode");
    <D.42967>:
    D.26988 = iftmp.367;
  }
  if (D.26988 == 0) goto <D.42968>; else goto <D.42928>;
  <D.42968>:
  D.42969 = mono_gc_is_moving ();
  if (D.42969 == 0) goto <D.42970>; else goto <D.42928>;
  <D.42970>:
  {
    int dreg;
    int t1;

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

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.42973 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.42973;
      inst->prev = 0B;
      D.42974 = inst->prev;
      inst->next = D.42974;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.42975 = inst->sreg3;
      inst->sreg2 = D.42975;
      D.42976 = inst->sreg2;
      inst->sreg1 = D.42976;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = t1;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg1 = D.42540;
      inst->data.op[1].const_val = 3;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.42977>; else goto <D.42978>;
      <D.42977>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.42979>;
      <D.42978>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.42979>:
    }
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 431;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = t1;
    ins->data.op[1].const_val = 2654435761;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.42980>; else goto <D.42981>;
    <D.42980>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.42982>;
    <D.42981>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.42982>:
    ins->type = 1;
    D.42736 = ins;
    return D.42736;
  }
  <D.42928>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.42984>; else goto <D.42985>;
    <D.42984>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42986 = ".ctor";
      D.42987 = MEM[(const unsigned char *)D.42986];
      D.42988 = (int) D.42987;
      D.42989 = *__s2;
      D.42990 = (int) D.42989;
      __result = D.42988 - D.42990;
      {
        if (__s2_len != 0) goto <D.42991>; else goto <D.42992>;
        <D.42991>:
        if (__result == 0) goto <D.42993>; else goto <D.42994>;
        <D.42993>:
        D.42995 = &MEM[(void *)".ctor" + 1B];
        D.42996 = *D.42995;
        D.42997 = (int) D.42996;
        D.42998 = __s2 + 1;
        D.42999 = *D.42998;
        D.43000 = (int) D.42999;
        __result = D.42997 - D.43000;
        if (__s2_len > 1) goto <D.43001>; else goto <D.43002>;
        <D.43001>:
        if (__result == 0) goto <D.43003>; else goto <D.43004>;
        <D.43003>:
        D.43005 = &MEM[(void *)".ctor" + 2B];
        D.43006 = *D.43005;
        D.43007 = (int) D.43006;
        D.43008 = __s2 + 2;
        D.43009 = *D.43008;
        D.43010 = (int) D.43009;
        __result = D.43007 - D.43010;
        if (__s2_len > 2) goto <D.43011>; else goto <D.43012>;
        <D.43011>:
        if (__result == 0) goto <D.43013>; else goto <D.43014>;
        <D.43013>:
        D.43015 = &MEM[(void *)".ctor" + 3B];
        D.43016 = *D.43015;
        D.43017 = (int) D.43016;
        D.43018 = __s2 + 3;
        D.43019 = *D.43018;
        D.43020 = (int) D.43019;
        __result = D.43017 - D.43020;
        <D.43014>:
        <D.43012>:
        <D.43004>:
        <D.43002>:
        <D.42994>:
        <D.42992>:
      }
      D.26999 = __result;
    }
    iftmp.368 = -D.26999;
    goto <D.43021>;
    <D.42985>:
    D.42503 = cmethod->name;
    iftmp.368 = __builtin_strcmp (D.42503, ".ctor");
    <D.43021>:
    D.27000 = iftmp.368;
  }
  if (D.27000 == 0) goto <D.43022>; else goto <D.43023>;
  <D.43022>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.43024>; else goto <D.43025>;
  <D.43024>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.43026>;
  <D.43025>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.43026>:
  D.42736 = ins;
  return D.42736;
  <D.43023>:
  D.42736 = 0B;
  return D.42736;
  <D.42853>:
  D.42460 = cmethod->klass;
  D.43027 = mono_defaults.array_class;
  if (D.42460 == D.43027) goto <D.43028>; else goto <D.43029>;
  <D.43028>:
  D.43030 = cfg->gsharedvt;
  if (D.43030 == 0) goto <D.43031>; else goto <D.43032>;
  <D.43031>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 18;
    if (__s2_len <= 3) goto <D.43034>; else goto <D.43035>;
    <D.43034>:
    {
      const unsigned char * __s2;
      int __result;

      D.42503 = cmethod->name;
      __s2 = D.42503 + 1;
      D.43036 = "etGenericValueImpl";
      D.43037 = MEM[(const unsigned char *)D.43036];
      D.43038 = (int) D.43037;
      D.43039 = *__s2;
      D.43040 = (int) D.43039;
      __result = D.43038 - D.43040;
      {
        if (__s2_len != 0) goto <D.43041>; else goto <D.43042>;
        <D.43041>:
        if (__result == 0) goto <D.43043>; else goto <D.43044>;
        <D.43043>:
        D.43045 = &MEM[(void *)"etGenericValueImpl" + 1B];
        D.43046 = *D.43045;
        D.43047 = (int) D.43046;
        D.43048 = __s2 + 1;
        D.43049 = *D.43048;
        D.43050 = (int) D.43049;
        __result = D.43047 - D.43050;
        if (__s2_len > 1) goto <D.43051>; else goto <D.43052>;
        <D.43051>:
        if (__result == 0) goto <D.43053>; else goto <D.43054>;
        <D.43053>:
        D.43055 = &MEM[(void *)"etGenericValueImpl" + 2B];
        D.43056 = *D.43055;
        D.43057 = (int) D.43056;
        D.43058 = __s2 + 2;
        D.43059 = *D.43058;
        D.43060 = (int) D.43059;
        __result = D.43057 - D.43060;
        if (__s2_len > 2) goto <D.43061>; else goto <D.43062>;
        <D.43061>:
        if (__result == 0) goto <D.43063>; else goto <D.43064>;
        <D.43063>:
        D.43065 = &MEM[(void *)"etGenericValueImpl" + 3B];
        D.43066 = *D.43065;
        D.43067 = (int) D.43066;
        D.43068 = __s2 + 3;
        D.43069 = *D.43068;
        D.43070 = (int) D.43069;
        __result = D.43067 - D.43070;
        <D.43064>:
        <D.43062>:
        <D.43054>:
        <D.43052>:
        <D.43044>:
        <D.43042>:
      }
      D.27008 = __result;
    }
    iftmp.369 = -D.27008;
    goto <D.43071>;
    <D.43035>:
    D.42503 = cmethod->name;
    D.43072 = D.42503 + 1;
    iftmp.369 = __builtin_strcmp (D.43072, "etGenericValueImpl");
    <D.43071>:
    D.27009 = iftmp.369;
  }
  if (D.27009 == 0) goto <D.43073>; else goto <D.43074>;
  <D.43073>:
  D.42503 = cmethod->name;
  D.43075 = *D.42503;
  D.43076 = D.43075 == 83;
  D.43077 = (int) D.43076;
  D.42736 = emit_array_generic_access (cfg, fsig, args, D.43077);
  return D.42736;
  <D.43074>:
  <D.43032>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.43081>; else goto <D.43082>;
    <D.43081>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43083 = "GetLength";
      D.43084 = MEM[(const unsigned char *)D.43083];
      D.43085 = (int) D.43084;
      D.43086 = *__s2;
      D.43087 = (int) D.43086;
      __result = D.43085 - D.43087;
      {
        if (__s2_len != 0) goto <D.43088>; else goto <D.43089>;
        <D.43088>:
        if (__result == 0) goto <D.43090>; else goto <D.43091>;
        <D.43090>:
        D.43092 = &MEM[(void *)"GetLength" + 1B];
        D.43093 = *D.43092;
        D.43094 = (int) D.43093;
        D.43095 = __s2 + 1;
        D.43096 = *D.43095;
        D.43097 = (int) D.43096;
        __result = D.43094 - D.43097;
        if (__s2_len > 1) goto <D.43098>; else goto <D.43099>;
        <D.43098>:
        if (__result == 0) goto <D.43100>; else goto <D.43101>;
        <D.43100>:
        D.43102 = &MEM[(void *)"GetLength" + 2B];
        D.43103 = *D.43102;
        D.43104 = (int) D.43103;
        D.43105 = __s2 + 2;
        D.43106 = *D.43105;
        D.43107 = (int) D.43106;
        __result = D.43104 - D.43107;
        if (__s2_len > 2) goto <D.43108>; else goto <D.43109>;
        <D.43108>:
        if (__result == 0) goto <D.43110>; else goto <D.43111>;
        <D.43110>:
        D.43112 = &MEM[(void *)"GetLength" + 3B];
        D.43113 = *D.43112;
        D.43114 = (int) D.43113;
        D.43115 = __s2 + 3;
        D.43116 = *D.43115;
        D.43117 = (int) D.43116;
        __result = D.43114 - D.43117;
        <D.43111>:
        <D.43109>:
        <D.43101>:
        <D.43099>:
        <D.43091>:
        <D.43089>:
      }
      D.27017 = __result;
    }
    iftmp.370 = -D.27017;
    goto <D.43118>;
    <D.43082>:
    D.42503 = cmethod->name;
    iftmp.370 = __builtin_strcmp (D.42503, "GetLength");
    <D.43118>:
    D.27018 = iftmp.370;
  }
  if (D.27018 == 0) goto <D.43078>; else goto <D.43119>;
  <D.43119>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 13;
    if (__s2_len <= 3) goto <D.43121>; else goto <D.43122>;
    <D.43121>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43123 = "GetLowerBound";
      D.43124 = MEM[(const unsigned char *)D.43123];
      D.43125 = (int) D.43124;
      D.43126 = *__s2;
      D.43127 = (int) D.43126;
      __result = D.43125 - D.43127;
      {
        if (__s2_len != 0) goto <D.43128>; else goto <D.43129>;
        <D.43128>:
        if (__result == 0) goto <D.43130>; else goto <D.43131>;
        <D.43130>:
        D.43132 = &MEM[(void *)"GetLowerBound" + 1B];
        D.43133 = *D.43132;
        D.43134 = (int) D.43133;
        D.43135 = __s2 + 1;
        D.43136 = *D.43135;
        D.43137 = (int) D.43136;
        __result = D.43134 - D.43137;
        if (__s2_len > 1) goto <D.43138>; else goto <D.43139>;
        <D.43138>:
        if (__result == 0) goto <D.43140>; else goto <D.43141>;
        <D.43140>:
        D.43142 = &MEM[(void *)"GetLowerBound" + 2B];
        D.43143 = *D.43142;
        D.43144 = (int) D.43143;
        D.43145 = __s2 + 2;
        D.43146 = *D.43145;
        D.43147 = (int) D.43146;
        __result = D.43144 - D.43147;
        if (__s2_len > 2) goto <D.43148>; else goto <D.43149>;
        <D.43148>:
        if (__result == 0) goto <D.43150>; else goto <D.43151>;
        <D.43150>:
        D.43152 = &MEM[(void *)"GetLowerBound" + 3B];
        D.43153 = *D.43152;
        D.43154 = (int) D.43153;
        D.43155 = __s2 + 3;
        D.43156 = *D.43155;
        D.43157 = (int) D.43156;
        __result = D.43154 - D.43157;
        <D.43151>:
        <D.43149>:
        <D.43141>:
        <D.43139>:
        <D.43131>:
        <D.43129>:
      }
      D.27026 = __result;
    }
    iftmp.371 = -D.27026;
    goto <D.43158>;
    <D.43122>:
    D.42503 = cmethod->name;
    iftmp.371 = __builtin_strcmp (D.42503, "GetLowerBound");
    <D.43158>:
    D.27027 = iftmp.371;
  }
  if (D.27027 == 0) goto <D.43078>; else goto <D.43079>;
  <D.43078>:
  D.42516 = args + 8;
  D.42517 = *D.42516;
  D.43159 = D.42517->opcode;
  if (D.43159 == 362) goto <D.43160>; else goto <D.43161>;
  <D.43160>:
  D.42516 = args + 8;
  D.42517 = *D.42516;
  D.43162 = D.42517->data.op[0].const_val;
  if (D.43162 == 0) goto <D.43163>; else goto <D.43164>;
  <D.43163>:
  {
    int dreg;
    int bounds_reg;
    struct MonoBasicBlock * end_bb;
    struct MonoBasicBlock * szarray_bb;
    gboolean get_length;

    D.43165 = alloc_ireg (cfg);
    dreg = (int) D.43165;
    D.43166 = alloc_ireg_mp (cfg);
    bounds_reg = (int) D.43166;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 9;
      if (__s2_len <= 3) goto <D.43168>; else goto <D.43169>;
      <D.43168>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = cmethod->name;
        D.43083 = "GetLength";
        D.43084 = MEM[(const unsigned char *)D.43083];
        D.43085 = (int) D.43084;
        D.43170 = *__s2;
        D.43171 = (int) D.43170;
        __result = D.43085 - D.43171;
        {
          if (__s2_len != 0) goto <D.43172>; else goto <D.43173>;
          <D.43172>:
          if (__result == 0) goto <D.43174>; else goto <D.43175>;
          <D.43174>:
          D.43092 = &MEM[(void *)"GetLength" + 1B];
          D.43093 = *D.43092;
          D.43094 = (int) D.43093;
          D.43176 = __s2 + 1;
          D.43177 = *D.43176;
          D.43178 = (int) D.43177;
          __result = D.43094 - D.43178;
          if (__s2_len > 1) goto <D.43179>; else goto <D.43180>;
          <D.43179>:
          if (__result == 0) goto <D.43181>; else goto <D.43182>;
          <D.43181>:
          D.43102 = &MEM[(void *)"GetLength" + 2B];
          D.43103 = *D.43102;
          D.43104 = (int) D.43103;
          D.43183 = __s2 + 2;
          D.43184 = *D.43183;
          D.43185 = (int) D.43184;
          __result = D.43104 - D.43185;
          if (__s2_len > 2) goto <D.43186>; else goto <D.43187>;
          <D.43186>:
          if (__result == 0) goto <D.43188>; else goto <D.43189>;
          <D.43188>:
          D.43112 = &MEM[(void *)"GetLength" + 3B];
          D.43113 = *D.43112;
          D.43114 = (int) D.43113;
          D.43190 = __s2 + 3;
          D.43191 = *D.43190;
          D.43192 = (int) D.43191;
          __result = D.43114 - D.43192;
          <D.43189>:
          <D.43187>:
          <D.43182>:
          <D.43180>:
          <D.43175>:
          <D.43173>:
        }
        D.27040 = __result;
      }
      iftmp.372 = -D.27040;
      goto <D.43193>;
      <D.43169>:
      D.42503 = cmethod->name;
      iftmp.372 = __builtin_strcmp (D.42503, "GetLength");
      <D.43193>:
      D.27041 = iftmp.372;
    }
    D.43194 = D.27041 == 0;
    get_length = (gboolean) D.43194;
    D.42510 = cfg->mempool;
    end_bb = mono_mempool_alloc0 (D.42510, 296);
    D.43195 = cfg->num_bblocks;
    D.43196 = D.43195;
    D.43197 = D.43196 + 1;
    cfg->num_bblocks = D.43197;
    D.43198 = (int) D.43196;
    end_bb->block_num = D.43198;
    D.42510 = cfg->mempool;
    szarray_bb = mono_mempool_alloc0 (D.42510, 296);
    D.43195 = cfg->num_bblocks;
    D.43199 = D.43195;
    D.43200 = D.43199 + 1;
    cfg->num_bblocks = D.43200;
    D.43201 = (int) D.43199;
    szarray_bb->block_num = D.43201;
    {
      int __ins_flags;

      __ins_flags = 32;
      D.43202 = __ins_flags & 32;
      if (D.43202 != 0) goto <D.43203>; else goto <D.43204>;
      <D.43203>:
      D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.42532 = D.42531 & 64;
      if (D.42532 != 0) goto <D.43205>; else goto <D.43206>;
      <D.43205>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43207 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43207;
        inst->prev = 0B;
        D.43208 = inst->prev;
        inst->next = D.43208;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43209 = inst->sreg3;
        inst->sreg2 = D.43209;
        D.43210 = inst->sreg2;
        inst->sreg1 = D.43210;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[1].const_val = 0;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43211>; else goto <D.43212>;
        <D.43211>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43213>;
        <D.43212>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43213>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43214 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43214;
        inst->prev = 0B;
        D.43215 = inst->prev;
        inst->next = D.43215;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43216 = inst->sreg3;
        inst->sreg2 = D.43216;
        D.43217 = inst->sreg2;
        inst->sreg1 = D.43217;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "NullReferenceException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43218>; else goto <D.43219>;
        <D.43218>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43220>;
        <D.43219>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43220>:
      }
      goto <D.43221>;
      <D.43206>:
      <D.43221>:
      <D.43204>:
      D.42510 = cfg->mempool;
      ins = mono_mempool_alloc (D.42510, 80);
      ins->data.op[1].const_val = 0;
      D.42729 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.42729;
      ins->prev = 0B;
      D.42730 = ins->prev;
      ins->next = D.42730;
      ins->opcode = 388;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.42731 = ins->sreg3;
      ins->sreg2 = D.42731;
      D.42732 = ins->sreg2;
      ins->sreg1 = D.42732;
      D.42515 = cfg->ip;
      ins->cil_code = D.42515;
      ins->dreg = bounds_reg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      ins->sreg1 = D.42540;
      ins->data.op[0].const_val = 16;
      ins->type = 1;
      D.43222 = (unsigned char) __ins_flags;
      ins->flags = D.43222;
    }
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43223>; else goto <D.43224>;
    <D.43223>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43225>;
    <D.43224>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43225>:
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 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 = 323;
      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.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = -1;
      inst->sreg1 = bounds_reg;
      inst->data.op[1].const_val = 0;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43230>; else goto <D.43231>;
      <D.43230>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.43232>;
      <D.43231>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43232>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.42510 = cfg->mempool;
      ins = mono_mempool_alloc (D.42510, 80);
      ins->data.op[1].const_val = 0;
      D.43233 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.43233;
      ins->prev = 0B;
      D.43234 = ins->prev;
      ins->next = D.43234;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.43235 = ins->sreg3;
      ins->sreg2 = D.43235;
      D.43236 = ins->sreg2;
      ins->sreg1 = D.43236;
      D.42515 = cfg->ip;
      ins->cil_code = D.42515;
      if (0 != 0) goto <D.43237>; else goto <D.43238>;
      <D.43237>:
      D.42510 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.42510, 296);
      D.43195 = cfg->num_bblocks;
      D.43239 = D.43195;
      D.43240 = D.43239 + 1;
      cfg->num_bblocks = D.43240;
      D.43241 = (int) D.43239;
      falsebb->block_num = D.43241;
      ins->data.op[0].target_block = szarray_bb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, szarray_bb);
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43242>; else goto <D.43243>;
      <D.43242>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = ins;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      ins->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      goto <D.43244>;
      <D.43243>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43244>:
      D.43245 = falsebb->cil_code;
      if (D.43245 != 0B) goto <D.43246>; else goto <D.43247>;
      <D.43246>:
      D.43248 = cfg->cil_offset_to_bb;
      D.43245 = falsebb->cil_code;
      D.43249 = (long int) D.43245;
      D.43250 = cfg->cil_start;
      D.43251 = (long int) D.43250;
      D.43252 = D.43249 - D.43251;
      D.43253 = (long unsigned int) D.43252;
      D.43254 = D.43253 * 8;
      D.43255 = D.43248 + D.43254;
      *D.43255 = falsebb;
      <D.43247>:
      D.43256 = cfg->real_offset;
      falsebb->real_offset = D.43256;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43260>; else goto <D.43257>;
      <D.43260>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 <= 9) goto <D.43258>; else goto <D.43263>;
      <D.43263>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 <= 9) goto <D.43258>; else goto <D.43265>;
      <D.43265>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 <= 9) goto <D.43258>; else goto <D.43257>;
      <D.43258>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      D.43269 = *D.43268;
      if (D.43269 == 0B) goto <D.43270>; else goto <D.43257>;
      <D.43270>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      *D.43268 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      goto <D.43259>;
      <D.43257>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 == 0B) goto <D.43271>; else goto <D.43273>;
      <D.43273>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 442) goto <D.43274>; else goto <D.43272>;
      <D.43274>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 759) goto <D.43275>; else goto <D.43272>;
      <D.43275>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 > 9) goto <D.43276>; else goto <D.43272>;
      <D.43276>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 > 9) goto <D.43277>; else goto <D.43272>;
      <D.43277>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 > 9) goto <D.43271>; else goto <D.43272>;
      <D.43271>:
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      <D.43272>:
      <D.43259>:
      D.42519 = cfg->cbb;
      D.42519->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43278>;
      <D.43238>:
      D.42510 = cfg->mempool;
      D.43279 = mono_mempool_alloc (D.42510, 16);
      ins->data.op[1].many_blocks = D.43279;
      D.43280 = ins->data.op[1].many_blocks;
      *D.43280 = szarray_bb;
      D.43280 = ins->data.op[1].many_blocks;
      D.43281 = D.43280 + 8;
      *D.43281 = 0B;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, szarray_bb);
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43282>; else goto <D.43283>;
      <D.43282>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = ins;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      ins->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      goto <D.43284>;
      <D.43283>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43284>:
      D.43285 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43286 = D.43285 & 34359738368;
      if (D.43286 == 0) goto <D.43287>; else goto <D.43288>;
      <D.43287>:
      D.42510 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.42510, 296);
      D.43195 = cfg->num_bblocks;
      D.43289 = D.43195;
      D.43290 = D.43289 + 1;
      cfg->num_bblocks = D.43290;
      D.43291 = (int) D.43289;
      falsebb->block_num = D.43291;
      D.43280 = ins->data.op[1].many_blocks;
      D.43281 = D.43280 + 8;
      *D.43281 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      D.43245 = falsebb->cil_code;
      if (D.43245 != 0B) goto <D.43292>; else goto <D.43293>;
      <D.43292>:
      D.43248 = cfg->cil_offset_to_bb;
      D.43245 = falsebb->cil_code;
      D.43249 = (long int) D.43245;
      D.43250 = cfg->cil_start;
      D.43251 = (long int) D.43250;
      D.43252 = D.43249 - D.43251;
      D.43253 = (long unsigned int) D.43252;
      D.43254 = D.43253 * 8;
      D.43255 = D.43248 + D.43254;
      *D.43255 = falsebb;
      <D.43293>:
      D.43256 = cfg->real_offset;
      falsebb->real_offset = D.43256;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43297>; else goto <D.43294>;
      <D.43297>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 <= 9) goto <D.43295>; else goto <D.43298>;
      <D.43298>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 <= 9) goto <D.43295>; else goto <D.43299>;
      <D.43299>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 <= 9) goto <D.43295>; else goto <D.43294>;
      <D.43295>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      D.43269 = *D.43268;
      if (D.43269 == 0B) goto <D.43300>; else goto <D.43294>;
      <D.43300>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      *D.43268 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      goto <D.43296>;
      <D.43294>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 == 0B) goto <D.43301>; else goto <D.43303>;
      <D.43303>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 442) goto <D.43304>; else goto <D.43302>;
      <D.43304>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 759) goto <D.43305>; else goto <D.43302>;
      <D.43305>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 > 9) goto <D.43306>; else goto <D.43302>;
      <D.43306>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 > 9) goto <D.43307>; else goto <D.43302>;
      <D.43307>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 > 9) goto <D.43301>; else goto <D.43302>;
      <D.43301>:
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      <D.43302>:
      <D.43296>:
      D.42519 = cfg->cbb;
      D.42519->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43308>;
      <D.43288>:
      D.42519 = cfg->cbb;
      D.42519->extended = 1;
      <D.43308>:
      <D.43278>:
    }
    if (get_length != 0) goto <D.43309>; else goto <D.43310>;
    <D.43309>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = bounds_reg;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43311>; else goto <D.43312>;
    <D.43311>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43313>;
    <D.43312>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43313>:
    goto <D.43314>;
    <D.43310>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = bounds_reg;
    ins->data.op[0].const_val = 4;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43315>; else goto <D.43316>;
    <D.43315>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43317>;
    <D.43316>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43317>:
    <D.43314>:
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.42510 = cfg->mempool;
      ins = mono_mempool_alloc (D.42510, 80);
      ins->data.op[1].const_val = 0;
      D.43318 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.43318;
      ins->prev = 0B;
      D.43319 = ins->prev;
      ins->next = D.43319;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.43320 = ins->sreg3;
      ins->sreg2 = D.43320;
      D.43321 = ins->sreg2;
      ins->sreg1 = D.43321;
      D.42515 = cfg->ip;
      ins->cil_code = D.42515;
      if (1 != 0) goto <D.43322>; else goto <D.43323>;
      <D.43322>:
      D.42510 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.42510, 296);
      D.43195 = cfg->num_bblocks;
      D.43324 = D.43195;
      D.43325 = D.43324 + 1;
      cfg->num_bblocks = D.43325;
      D.43326 = (int) D.43324;
      falsebb->block_num = D.43326;
      ins->data.op[0].target_block = end_bb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, end_bb);
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43327>; else goto <D.43328>;
      <D.43327>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = ins;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      ins->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      goto <D.43329>;
      <D.43328>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43329>:
      D.43330 = falsebb->cil_code;
      if (D.43330 != 0B) goto <D.43331>; else goto <D.43332>;
      <D.43331>:
      D.43248 = cfg->cil_offset_to_bb;
      D.43330 = falsebb->cil_code;
      D.43333 = (long int) D.43330;
      D.43250 = cfg->cil_start;
      D.43251 = (long int) D.43250;
      D.43334 = D.43333 - D.43251;
      D.43335 = (long unsigned int) D.43334;
      D.43336 = D.43335 * 8;
      D.43337 = D.43248 + D.43336;
      *D.43337 = falsebb;
      <D.43332>:
      D.43256 = cfg->real_offset;
      falsebb->real_offset = D.43256;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43341>; else goto <D.43338>;
      <D.43341>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 <= 9) goto <D.43339>; else goto <D.43342>;
      <D.43342>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 <= 9) goto <D.43339>; else goto <D.43343>;
      <D.43343>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 <= 9) goto <D.43339>; else goto <D.43338>;
      <D.43339>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      D.43269 = *D.43268;
      if (D.43269 == 0B) goto <D.43344>; else goto <D.43338>;
      <D.43344>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      *D.43268 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      goto <D.43340>;
      <D.43338>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 == 0B) goto <D.43345>; else goto <D.43347>;
      <D.43347>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 442) goto <D.43348>; else goto <D.43346>;
      <D.43348>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 759) goto <D.43349>; else goto <D.43346>;
      <D.43349>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 > 9) goto <D.43350>; else goto <D.43346>;
      <D.43350>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 > 9) goto <D.43351>; else goto <D.43346>;
      <D.43351>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 > 9) goto <D.43345>; else goto <D.43346>;
      <D.43345>:
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      <D.43346>:
      <D.43340>:
      D.42519 = cfg->cbb;
      D.42519->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43352>;
      <D.43323>:
      D.42510 = cfg->mempool;
      D.43353 = mono_mempool_alloc (D.42510, 16);
      ins->data.op[1].many_blocks = D.43353;
      D.43354 = ins->data.op[1].many_blocks;
      *D.43354 = end_bb;
      D.43354 = ins->data.op[1].many_blocks;
      D.43355 = D.43354 + 8;
      *D.43355 = 0B;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, end_bb);
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43356>; else goto <D.43357>;
      <D.43356>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = ins;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      ins->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      goto <D.43358>;
      <D.43357>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = ins;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43358>:
      D.43285 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43286 = D.43285 & 34359738368;
      if (D.43286 == 0) goto <D.43359>; else goto <D.43360>;
      <D.43359>:
      D.42510 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.42510, 296);
      D.43195 = cfg->num_bblocks;
      D.43361 = D.43195;
      D.43362 = D.43361 + 1;
      cfg->num_bblocks = D.43362;
      D.43363 = (int) D.43361;
      falsebb->block_num = D.43363;
      D.43354 = ins->data.op[1].many_blocks;
      D.43355 = D.43354 + 8;
      *D.43355 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      D.43330 = falsebb->cil_code;
      if (D.43330 != 0B) goto <D.43364>; else goto <D.43365>;
      <D.43364>:
      D.43248 = cfg->cil_offset_to_bb;
      D.43330 = falsebb->cil_code;
      D.43333 = (long int) D.43330;
      D.43250 = cfg->cil_start;
      D.43251 = (long int) D.43250;
      D.43334 = D.43333 - D.43251;
      D.43335 = (long unsigned int) D.43334;
      D.43336 = D.43335 * 8;
      D.43337 = D.43248 + D.43336;
      *D.43337 = falsebb;
      <D.43365>:
      D.43256 = cfg->real_offset;
      falsebb->real_offset = D.43256;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43369>; else goto <D.43366>;
      <D.43369>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 <= 9) goto <D.43367>; else goto <D.43370>;
      <D.43370>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 <= 9) goto <D.43367>; else goto <D.43371>;
      <D.43371>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 <= 9) goto <D.43367>; else goto <D.43366>;
      <D.43367>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      D.43269 = *D.43268;
      if (D.43269 == 0B) goto <D.43372>; else goto <D.43366>;
      <D.43372>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43267 = D.42520->data.op[1].many_blocks;
      D.43268 = D.43267 + 8;
      *D.43268 = falsebb;
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      goto <D.43368>;
      <D.43366>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 == 0B) goto <D.43373>; else goto <D.43375>;
      <D.43375>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 442) goto <D.43376>; else goto <D.43374>;
      <D.43376>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      if (D.43261 != 759) goto <D.43377>; else goto <D.43374>;
      <D.43377>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43262 = D.43261 + 64985;
      if (D.43262 > 9) goto <D.43378>; else goto <D.43374>;
      <D.43378>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43264 = D.43261 + 64878;
      if (D.43264 > 9) goto <D.43379>; else goto <D.43374>;
      <D.43379>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.43261 = D.42520->opcode;
      D.43266 = D.43261 + 64888;
      if (D.43266 > 9) goto <D.43373>; else goto <D.43374>;
      <D.43373>:
      D.42519 = cfg->cbb;
      mono_link_bblock (cfg, D.42519, falsebb);
      <D.43374>:
      <D.43368>:
      D.42519 = cfg->cbb;
      D.42519->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43380>;
      <D.43360>:
      D.42519 = cfg->cbb;
      D.42519->extended = 1;
      <D.43380>:
      <D.43352>:
    }
    D.43381 = szarray_bb->cil_code;
    if (D.43381 != 0B) goto <D.43382>; else goto <D.43383>;
    <D.43382>:
    D.43248 = cfg->cil_offset_to_bb;
    D.43381 = szarray_bb->cil_code;
    D.43384 = (long int) D.43381;
    D.43250 = cfg->cil_start;
    D.43251 = (long int) D.43250;
    D.43385 = D.43384 - D.43251;
    D.43386 = (long unsigned int) D.43385;
    D.43387 = D.43386 * 8;
    D.43388 = D.43248 + D.43387;
    *D.43388 = szarray_bb;
    <D.43383>:
    D.43256 = cfg->real_offset;
    szarray_bb->real_offset = D.43256;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43392>; else goto <D.43389>;
    <D.43392>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43262 = D.43261 + 64985;
    if (D.43262 <= 9) goto <D.43390>; else goto <D.43393>;
    <D.43393>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43264 = D.43261 + 64878;
    if (D.43264 <= 9) goto <D.43390>; else goto <D.43394>;
    <D.43394>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43266 = D.43261 + 64888;
    if (D.43266 <= 9) goto <D.43390>; else goto <D.43389>;
    <D.43390>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43267 = D.42520->data.op[1].many_blocks;
    D.43268 = D.43267 + 8;
    D.43269 = *D.43268;
    if (D.43269 == 0B) goto <D.43395>; else goto <D.43389>;
    <D.43395>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43267 = D.42520->data.op[1].many_blocks;
    D.43268 = D.43267 + 8;
    *D.43268 = szarray_bb;
    D.42519 = cfg->cbb;
    mono_link_bblock (cfg, D.42519, szarray_bb);
    goto <D.43391>;
    <D.43389>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 == 0B) goto <D.43396>; else goto <D.43398>;
    <D.43398>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    if (D.43261 != 442) goto <D.43399>; else goto <D.43397>;
    <D.43399>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    if (D.43261 != 759) goto <D.43400>; else goto <D.43397>;
    <D.43400>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43262 = D.43261 + 64985;
    if (D.43262 > 9) goto <D.43401>; else goto <D.43397>;
    <D.43401>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43264 = D.43261 + 64878;
    if (D.43264 > 9) goto <D.43402>; else goto <D.43397>;
    <D.43402>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43266 = D.43261 + 64888;
    if (D.43266 > 9) goto <D.43396>; else goto <D.43397>;
    <D.43396>:
    D.42519 = cfg->cbb;
    mono_link_bblock (cfg, D.42519, szarray_bb);
    <D.43397>:
    <D.43391>:
    D.42519 = cfg->cbb;
    D.42519->next_bb = szarray_bb;
    cfg->cbb = szarray_bb;
    if (get_length != 0) goto <D.43403>; else goto <D.43404>;
    <D.43403>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    ins->data.op[0].const_val = 24;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43405>; else goto <D.43406>;
    <D.43405>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43407>;
    <D.43406>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43407>:
    goto <D.43408>;
    <D.43404>:
    {
      struct MonoInst * inst;

      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 80);
      inst->data.op[1].const_val = 0;
      D.43409 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43409;
      inst->prev = 0B;
      D.43410 = inst->prev;
      inst->next = D.43410;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43411 = inst->sreg3;
      inst->sreg2 = D.43411;
      D.43412 = inst->sreg2;
      inst->sreg1 = D.43412;
      D.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = dreg;
      inst->data.op[0].const_val = 0;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43413>; else goto <D.43414>;
      <D.43413>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.43415>;
      <D.43414>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43415>:
    }
    <D.43408>:
    D.43416 = end_bb->cil_code;
    if (D.43416 != 0B) goto <D.43417>; else goto <D.43418>;
    <D.43417>:
    D.43248 = cfg->cil_offset_to_bb;
    D.43416 = end_bb->cil_code;
    D.43419 = (long int) D.43416;
    D.43250 = cfg->cil_start;
    D.43251 = (long int) D.43250;
    D.43420 = D.43419 - D.43251;
    D.43421 = (long unsigned int) D.43420;
    D.43422 = D.43421 * 8;
    D.43423 = D.43248 + D.43422;
    *D.43423 = end_bb;
    <D.43418>:
    D.43256 = cfg->real_offset;
    end_bb->real_offset = D.43256;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43427>; else goto <D.43424>;
    <D.43427>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43262 = D.43261 + 64985;
    if (D.43262 <= 9) goto <D.43425>; else goto <D.43428>;
    <D.43428>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43264 = D.43261 + 64878;
    if (D.43264 <= 9) goto <D.43425>; else goto <D.43429>;
    <D.43429>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43266 = D.43261 + 64888;
    if (D.43266 <= 9) goto <D.43425>; else goto <D.43424>;
    <D.43425>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43267 = D.42520->data.op[1].many_blocks;
    D.43268 = D.43267 + 8;
    D.43269 = *D.43268;
    if (D.43269 == 0B) goto <D.43430>; else goto <D.43424>;
    <D.43430>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43267 = D.42520->data.op[1].many_blocks;
    D.43268 = D.43267 + 8;
    *D.43268 = end_bb;
    D.42519 = cfg->cbb;
    mono_link_bblock (cfg, D.42519, end_bb);
    goto <D.43426>;
    <D.43424>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 == 0B) goto <D.43431>; else goto <D.43433>;
    <D.43433>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    if (D.43261 != 442) goto <D.43434>; else goto <D.43432>;
    <D.43434>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    if (D.43261 != 759) goto <D.43435>; else goto <D.43432>;
    <D.43435>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43262 = D.43261 + 64985;
    if (D.43262 > 9) goto <D.43436>; else goto <D.43432>;
    <D.43436>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43264 = D.43261 + 64878;
    if (D.43264 > 9) goto <D.43437>; else goto <D.43432>;
    <D.43437>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.43261 = D.42520->opcode;
    D.43266 = D.43261 + 64888;
    if (D.43266 > 9) goto <D.43431>; else goto <D.43432>;
    <D.43431>:
    D.42519 = cfg->cbb;
    mono_link_bblock (cfg, D.42519, end_bb);
    <D.43432>:
    <D.43426>:
    D.42519 = cfg->cbb;
    D.42519->next_bb = end_bb;
    cfg->cbb = end_bb;
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 424;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = dreg;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43438>; else goto <D.43439>;
    <D.43438>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43440>;
    <D.43439>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43440>:
    ins->type = 1;
    D.42736 = ins;
    return D.42736;
  }
  <D.43164>:
  <D.43161>:
  <D.43079>:
  D.42503 = cmethod->name;
  D.43075 = *D.42503;
  if (D.43075 != 103) goto <D.43441>; else goto <D.43442>;
  <D.43441>:
  D.42736 = 0B;
  return D.42736;
  <D.43442>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.43446 = "get_Rank";
      D.43447 = MEM[(const unsigned char *)D.43446];
      D.43448 = (int) D.43447;
      D.43449 = *__s2;
      D.43450 = (int) D.43449;
      __result = D.43448 - D.43450;
      {
        if (__s2_len != 0) goto <D.43451>; else goto <D.43452>;
        <D.43451>:
        if (__result == 0) goto <D.43453>; else goto <D.43454>;
        <D.43453>:
        D.43455 = &MEM[(void *)"get_Rank" + 1B];
        D.43456 = *D.43455;
        D.43457 = (int) D.43456;
        D.43458 = __s2 + 1;
        D.43459 = *D.43458;
        D.43460 = (int) D.43459;
        __result = D.43457 - D.43460;
        if (__s2_len > 1) goto <D.43461>; else goto <D.43462>;
        <D.43461>:
        if (__result == 0) goto <D.43463>; else goto <D.43464>;
        <D.43463>:
        D.43465 = &MEM[(void *)"get_Rank" + 2B];
        D.43466 = *D.43465;
        D.43467 = (int) D.43466;
        D.43468 = __s2 + 2;
        D.43469 = *D.43468;
        D.43470 = (int) D.43469;
        __result = D.43467 - D.43470;
        if (__s2_len > 2) goto <D.43471>; else goto <D.43472>;
        <D.43471>:
        if (__result == 0) goto <D.43473>; else goto <D.43474>;
        <D.43473>:
        D.43475 = &MEM[(void *)"get_Rank" + 3B];
        D.43476 = *D.43475;
        D.43477 = (int) D.43476;
        D.43478 = __s2 + 3;
        D.43479 = *D.43478;
        D.43480 = (int) D.43479;
        __result = D.43477 - D.43480;
        <D.43474>:
        <D.43472>:
        <D.43464>:
        <D.43462>:
        <D.43454>:
        <D.43452>:
      }
      D.27058 = __result;
    }
    iftmp.373 = -D.27058;
    goto <D.43481>;
    <D.43445>:
    D.42503 = cmethod->name;
    iftmp.373 = __builtin_strcmp (D.42503, "get_Rank");
    <D.43481>:
    D.27059 = iftmp.373;
  }
  if (D.27059 == 0) goto <D.43482>; else goto <D.43483>;
  <D.43482>:
  {
    int dreg;
    int vtable_reg;

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

      __ins_flags = 32;
      D.43486 = __ins_flags & 32;
      if (D.43486 != 0) goto <D.43487>; else goto <D.43488>;
      <D.43487>:
      D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.42532 = D.42531 & 64;
      if (D.42532 != 0) goto <D.43489>; else goto <D.43490>;
      <D.43489>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43491 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43491;
        inst->prev = 0B;
        D.43492 = inst->prev;
        inst->next = D.43492;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43493 = inst->sreg3;
        inst->sreg2 = D.43493;
        D.43494 = inst->sreg2;
        inst->sreg1 = D.43494;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[1].const_val = 0;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43495>; else goto <D.43496>;
        <D.43495>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43497>;
        <D.43496>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43497>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43498 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43498;
        inst->prev = 0B;
        D.43499 = inst->prev;
        inst->next = D.43499;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43500 = inst->sreg3;
        inst->sreg2 = D.43500;
        D.43501 = inst->sreg2;
        inst->sreg1 = D.43501;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "NullReferenceException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43502>; else goto <D.43503>;
        <D.43502>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43504>;
        <D.43503>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43504>:
      }
      goto <D.43505>;
      <D.43490>:
      <D.43505>:
      <D.43488>:
      D.42510 = cfg->mempool;
      inst = mono_mempool_alloc (D.42510, 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.42515 = cfg->ip;
      inst->cil_code = D.42515;
      inst->dreg = vtable_reg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      inst->sreg1 = D.42540;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.43510 = (unsigned char) __ins_flags;
      inst->flags = D.43510;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      if (D.42520 != 0B) goto <D.43511>; else goto <D.43512>;
      <D.43511>:
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      D.42520->next = inst;
      D.42519 = cfg->cbb;
      D.42520 = D.42519->last_ins;
      inst->prev = D.42520;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      goto <D.43513>;
      <D.43512>:
      D.42519 = cfg->cbb;
      D.42519 = cfg->cbb;
      D.42519->last_ins = inst;
      D.42520 = D.42519->last_ins;
      D.42519->code = D.42520;
      <D.43513>:
    }
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 390;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    ins->dreg = dreg;
    ins->sreg1 = vtable_reg;
    ins->data.op[0].const_val = 42;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43514>; else goto <D.43515>;
    <D.43514>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43516>;
    <D.43515>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43516>:
    type_from_op (ins, 0B, 0B);
    D.42736 = ins;
    return D.42736;
  }
  <D.43483>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.43518>; else goto <D.43519>;
    <D.43518>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.42740 = "get_Length";
      D.42741 = MEM[(const unsigned char *)D.42740];
      D.42742 = (int) D.42741;
      D.43520 = *__s2;
      D.43521 = (int) D.43520;
      __result = D.42742 - D.43521;
      {
        if (__s2_len != 0) goto <D.43522>; else goto <D.43523>;
        <D.43522>:
        if (__result == 0) goto <D.43524>; else goto <D.43525>;
        <D.43524>:
        D.42749 = &MEM[(void *)"get_Length" + 1B];
        D.42750 = *D.42749;
        D.42751 = (int) D.42750;
        D.43526 = __s2 + 1;
        D.43527 = *D.43526;
        D.43528 = (int) D.43527;
        __result = D.42751 - D.43528;
        if (__s2_len > 1) goto <D.43529>; else goto <D.43530>;
        <D.43529>:
        if (__result == 0) goto <D.43531>; else goto <D.43532>;
        <D.43531>:
        D.42759 = &MEM[(void *)"get_Length" + 2B];
        D.42760 = *D.42759;
        D.42761 = (int) D.42760;
        D.43533 = __s2 + 2;
        D.43534 = *D.43533;
        D.43535 = (int) D.43534;
        __result = D.42761 - D.43535;
        if (__s2_len > 2) goto <D.43536>; else goto <D.43537>;
        <D.43536>:
        if (__result == 0) goto <D.43538>; else goto <D.43539>;
        <D.43538>:
        D.42769 = &MEM[(void *)"get_Length" + 3B];
        D.42770 = *D.42769;
        D.42771 = (int) D.42770;
        D.43540 = __s2 + 3;
        D.43541 = *D.43540;
        D.43542 = (int) D.43541;
        __result = D.42771 - D.43542;
        <D.43539>:
        <D.43537>:
        <D.43532>:
        <D.43530>:
        <D.43525>:
        <D.43523>:
      }
      D.27073 = __result;
    }
    iftmp.374 = -D.27073;
    goto <D.43543>;
    <D.43519>:
    D.42503 = cmethod->name;
    iftmp.374 = __builtin_strcmp (D.42503, "get_Length");
    <D.43543>:
    D.27074 = iftmp.374;
  }
  if (D.27074 == 0) goto <D.43544>; else goto <D.43545>;
  <D.43544>:
  {
    int dreg;

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

      __ins_flags = 32;
      D.43547 = __ins_flags & 32;
      if (D.43547 != 0) goto <D.43548>; else goto <D.43549>;
      <D.43548>:
      D.42531 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.42532 = D.42531 & 64;
      if (D.42532 != 0) goto <D.43550>; else goto <D.43551>;
      <D.43550>:
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43552 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43552;
        inst->prev = 0B;
        D.43553 = inst->prev;
        inst->next = D.43553;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43554 = inst->sreg3;
        inst->sreg2 = D.43554;
        D.43555 = inst->sreg2;
        inst->sreg1 = D.43555;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->dreg = -1;
        D.42539 = *args;
        D.42540 = D.42539->dreg;
        inst->sreg1 = D.42540;
        inst->data.op[1].const_val = 0;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43556>; else goto <D.43557>;
        <D.43556>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43558>;
        <D.43557>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43558>:
      }
      {
        struct MonoInst * inst;

        D.42510 = cfg->mempool;
        inst = mono_mempool_alloc (D.42510, 80);
        inst->data.op[1].const_val = 0;
        D.43559 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43559;
        inst->prev = 0B;
        D.43560 = inst->prev;
        inst->next = D.43560;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43561 = inst->sreg3;
        inst->sreg2 = D.43561;
        D.43562 = inst->sreg2;
        inst->sreg1 = D.43562;
        D.42515 = cfg->ip;
        inst->cil_code = D.42515;
        inst->data.op[1].p = "NullReferenceException";
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        if (D.42520 != 0B) goto <D.43563>; else goto <D.43564>;
        <D.43563>:
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        D.42520->next = inst;
        D.42519 = cfg->cbb;
        D.42520 = D.42519->last_ins;
        inst->prev = D.42520;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        goto <D.43565>;
        <D.43564>:
        D.42519 = cfg->cbb;
        D.42519 = cfg->cbb;
        D.42519->last_ins = inst;
        D.42520 = D.42519->last_ins;
        D.42519->code = D.42520;
        <D.43565>:
      }
      goto <D.43566>;
      <D.43551>:
      <D.43566>:
      <D.43549>:
      D.42510 = cfg->mempool;
      ins = mono_mempool_alloc (D.42510, 80);
      ins->data.op[1].const_val = 0;
      D.42729 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.42729;
      ins->prev = 0B;
      D.42730 = ins->prev;
      ins->next = D.42730;
      ins->opcode = 393;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.42731 = ins->sreg3;
      ins->sreg2 = D.42731;
      D.42732 = ins->sreg2;
      ins->sreg1 = D.42732;
      D.42515 = cfg->ip;
      ins->cil_code = D.42515;
      ins->dreg = dreg;
      D.42539 = *args;
      D.42540 = D.42539->dreg;
      ins->sreg1 = D.42540;
      ins->data.op[0].const_val = 24;
      ins->type = 1;
      D.43567 = (unsigned char) __ins_flags;
      ins->flags = D.43567;
    }
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.43568>; else goto <D.43569>;
    <D.43568>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.43570>;
    <D.43569>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.43570>:
    type_from_op (ins, 0B, 0B);
    D.42736 = ins;
    return D.42736;
  }
  <D.43545>:
  D.42736 = 0B;
  return D.42736;
  <D.43029>:
  D.42460 = cmethod->klass;
  runtime_helpers_class.361 = runtime_helpers_class;
  if (D.42460 == runtime_helpers_class.361) goto <D.43571>; else goto <D.43572>;
  <D.43571>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 22;
    if (__s2_len <= 3) goto <D.43574>; else goto <D.43575>;
    <D.43574>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43576 = "get_OffsetToStringData";
      D.43577 = MEM[(const unsigned char *)D.43576];
      D.43578 = (int) D.43577;
      D.43579 = *__s2;
      D.43580 = (int) D.43579;
      __result = D.43578 - D.43580;
      {
        if (__s2_len != 0) goto <D.43581>; else goto <D.43582>;
        <D.43581>:
        if (__result == 0) goto <D.43583>; else goto <D.43584>;
        <D.43583>:
        D.43585 = &MEM[(void *)"get_OffsetToStringData" + 1B];
        D.43586 = *D.43585;
        D.43587 = (int) D.43586;
        D.43588 = __s2 + 1;
        D.43589 = *D.43588;
        D.43590 = (int) D.43589;
        __result = D.43587 - D.43590;
        if (__s2_len > 1) goto <D.43591>; else goto <D.43592>;
        <D.43591>:
        if (__result == 0) goto <D.43593>; else goto <D.43594>;
        <D.43593>:
        D.43595 = &MEM[(void *)"get_OffsetToStringData" + 2B];
        D.43596 = *D.43595;
        D.43597 = (int) D.43596;
        D.43598 = __s2 + 2;
        D.43599 = *D.43598;
        D.43600 = (int) D.43599;
        __result = D.43597 - D.43600;
        if (__s2_len > 2) goto <D.43601>; else goto <D.43602>;
        <D.43601>:
        if (__result == 0) goto <D.43603>; else goto <D.43604>;
        <D.43603>:
        D.43605 = &MEM[(void *)"get_OffsetToStringData" + 3B];
        D.43606 = *D.43605;
        D.43607 = (int) D.43606;
        D.43608 = __s2 + 3;
        D.43609 = *D.43608;
        D.43610 = (int) D.43609;
        __result = D.43607 - D.43610;
        <D.43604>:
        <D.43602>:
        <D.43594>:
        <D.43592>:
        <D.43584>:
        <D.43582>:
      }
      D.27086 = __result;
    }
    iftmp.375 = -D.27086;
    goto <D.43611>;
    <D.43575>:
    D.42503 = cmethod->name;
    iftmp.375 = __builtin_strcmp (D.42503, "get_OffsetToStringData");
    <D.43611>:
    D.27087 = iftmp.375;
  }
  if (D.27087 == 0) goto <D.43612>; else goto <D.43613>;
  <D.43612>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  ins->data.op[0].const_val = 20;
  ins->type = 1;
  D.43614 = alloc_dreg (cfg, 1);
  D.43615 = (int) D.43614;
  ins->dreg = D.43615;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.43616>; else goto <D.43617>;
  <D.43616>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.43618>;
  <D.43617>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.43618>:
  D.42736 = ins;
  return D.42736;
  <D.43613>:
  D.42736 = 0B;
  return D.42736;
  <D.43572>:
  D.42460 = cmethod->klass;
  D.43619 = mono_defaults.thread_class;
  if (D.42460 == D.43619) goto <D.43620>; else goto <D.43621>;
  <D.43620>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.43623>; else goto <D.43624>;
    <D.43623>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43625 = "SpinWait_nop";
      D.43626 = MEM[(const unsigned char *)D.43625];
      D.43627 = (int) D.43626;
      D.43628 = *__s2;
      D.43629 = (int) D.43628;
      __result = D.43627 - D.43629;
      {
        if (__s2_len != 0) goto <D.43630>; else goto <D.43631>;
        <D.43630>:
        if (__result == 0) goto <D.43632>; else goto <D.43633>;
        <D.43632>:
        D.43634 = &MEM[(void *)"SpinWait_nop" + 1B];
        D.43635 = *D.43634;
        D.43636 = (int) D.43635;
        D.43637 = __s2 + 1;
        D.43638 = *D.43637;
        D.43639 = (int) D.43638;
        __result = D.43636 - D.43639;
        if (__s2_len > 1) goto <D.43640>; else goto <D.43641>;
        <D.43640>:
        if (__result == 0) goto <D.43642>; else goto <D.43643>;
        <D.43642>:
        D.43644 = &MEM[(void *)"SpinWait_nop" + 2B];
        D.43645 = *D.43644;
        D.43646 = (int) D.43645;
        D.43647 = __s2 + 2;
        D.43648 = *D.43647;
        D.43649 = (int) D.43648;
        __result = D.43646 - D.43649;
        if (__s2_len > 2) goto <D.43650>; else goto <D.43651>;
        <D.43650>:
        if (__result == 0) goto <D.43652>; else goto <D.43653>;
        <D.43652>:
        D.43654 = &MEM[(void *)"SpinWait_nop" + 3B];
        D.43655 = *D.43654;
        D.43656 = (int) D.43655;
        D.43657 = __s2 + 3;
        D.43658 = *D.43657;
        D.43659 = (int) D.43658;
        __result = D.43656 - D.43659;
        <D.43653>:
        <D.43651>:
        <D.43643>:
        <D.43641>:
        <D.43633>:
        <D.43631>:
      }
      D.27095 = __result;
    }
    iftmp.376 = -D.27095;
    goto <D.43660>;
    <D.43624>:
    D.42503 = cmethod->name;
    iftmp.376 = __builtin_strcmp (D.42503, "SpinWait_nop");
    <D.43660>:
    D.27096 = iftmp.376;
  }
  if (D.27096 == 0) goto <D.43661>; else goto <D.43662>;
  <D.43661>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 318;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.43663>; else goto <D.43664>;
  <D.43663>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.43665>;
  <D.43664>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.43665>:
  D.42736 = ins;
  return D.42736;
  <D.43662>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 13;
    if (__s2_len <= 3) goto <D.43667>; else goto <D.43668>;
    <D.43667>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43669 = "MemoryBarrier";
      D.43670 = MEM[(const unsigned char *)D.43669];
      D.43671 = (int) D.43670;
      D.43672 = *__s2;
      D.43673 = (int) D.43672;
      __result = D.43671 - D.43673;
      {
        if (__s2_len != 0) goto <D.43674>; else goto <D.43675>;
        <D.43674>:
        if (__result == 0) goto <D.43676>; else goto <D.43677>;
        <D.43676>:
        D.43678 = &MEM[(void *)"MemoryBarrier" + 1B];
        D.43679 = *D.43678;
        D.43680 = (int) D.43679;
        D.43681 = __s2 + 1;
        D.43682 = *D.43681;
        D.43683 = (int) D.43682;
        __result = D.43680 - D.43683;
        if (__s2_len > 1) goto <D.43684>; else goto <D.43685>;
        <D.43684>:
        if (__result == 0) goto <D.43686>; else goto <D.43687>;
        <D.43686>:
        D.43688 = &MEM[(void *)"MemoryBarrier" + 2B];
        D.43689 = *D.43688;
        D.43690 = (int) D.43689;
        D.43691 = __s2 + 2;
        D.43692 = *D.43691;
        D.43693 = (int) D.43692;
        __result = D.43690 - D.43693;
        if (__s2_len > 2) goto <D.43694>; else goto <D.43695>;
        <D.43694>:
        if (__result == 0) goto <D.43696>; else goto <D.43697>;
        <D.43696>:
        D.43698 = &MEM[(void *)"MemoryBarrier" + 3B];
        D.43699 = *D.43698;
        D.43700 = (int) D.43699;
        D.43701 = __s2 + 3;
        D.43702 = *D.43701;
        D.43703 = (int) D.43702;
        __result = D.43700 - D.43703;
        <D.43697>:
        <D.43695>:
        <D.43687>:
        <D.43685>:
        <D.43677>:
        <D.43675>:
      }
      D.27104 = __result;
    }
    iftmp.377 = -D.27104;
    goto <D.43704>;
    <D.43668>:
    D.42503 = cmethod->name;
    iftmp.377 = __builtin_strcmp (D.42503, "MemoryBarrier");
    <D.43704>:
    D.27105 = iftmp.377;
  }
  if (D.27105 == 0) goto <D.43705>; else goto <D.43706>;
  <D.43705>:
  D.42736 = emit_memory_barrier (cfg, 4);
  return D.42736;
  <D.43706>:
  goto <D.43707>;
  <D.43621>:
  D.42460 = cmethod->klass;
  D.43708 = mono_defaults.monitor_class;
  if (D.42460 == D.43708) goto <D.43709>; else goto <D.43710>;
  <D.43709>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.43712>; else goto <D.43713>;
    <D.43712>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43714 = "Enter";
      D.43715 = MEM[(const unsigned char *)D.43714];
      D.43716 = (int) D.43715;
      D.43717 = *__s2;
      D.43718 = (int) D.43717;
      __result = D.43716 - D.43718;
      {
        if (__s2_len != 0) goto <D.43719>; else goto <D.43720>;
        <D.43719>:
        if (__result == 0) goto <D.43721>; else goto <D.43722>;
        <D.43721>:
        D.43723 = &MEM[(void *)"Enter" + 1B];
        D.43724 = *D.43723;
        D.43725 = (int) D.43724;
        D.43726 = __s2 + 1;
        D.43727 = *D.43726;
        D.43728 = (int) D.43727;
        __result = D.43725 - D.43728;
        if (__s2_len > 1) goto <D.43729>; else goto <D.43730>;
        <D.43729>:
        if (__result == 0) goto <D.43731>; else goto <D.43732>;
        <D.43731>:
        D.43733 = &MEM[(void *)"Enter" + 2B];
        D.43734 = *D.43733;
        D.43735 = (int) D.43734;
        D.43736 = __s2 + 2;
        D.43737 = *D.43736;
        D.43738 = (int) D.43737;
        __result = D.43735 - D.43738;
        if (__s2_len > 2) goto <D.43739>; else goto <D.43740>;
        <D.43739>:
        if (__result == 0) goto <D.43741>; else goto <D.43742>;
        <D.43741>:
        D.43743 = &MEM[(void *)"Enter" + 3B];
        D.43744 = *D.43743;
        D.43745 = (int) D.43744;
        D.43746 = __s2 + 3;
        D.43747 = *D.43746;
        D.43748 = (int) D.43747;
        __result = D.43745 - D.43748;
        <D.43742>:
        <D.43740>:
        <D.43732>:
        <D.43730>:
        <D.43722>:
        <D.43720>:
      }
      D.27113 = __result;
    }
    iftmp.378 = -D.27113;
    goto <D.43749>;
    <D.43713>:
    D.42503 = cmethod->name;
    iftmp.378 = __builtin_strcmp (D.42503, "Enter");
    <D.43749>:
    D.27114 = iftmp.378;
  }
  if (D.27114 == 0) goto <D.43750>; else goto <D.43751>;
  <D.43750>:
  D.43752 = fsig->param_count;
  if (D.43752 == 2) goto <D.43753>; else goto <D.43754>;
  <D.43753>:
  {
    struct MonoMethod * fast_method;

    fast_method = 0B;
    D.43755 = cfg->method;
    D.43756 = BIT_FIELD_REF <*D.43755, 64, 256>;
    D.43757 = D.43756 & 124;
    if (D.43757 == 100) goto <D.43758>; else goto <D.43759>;
    <D.43758>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 18;
      if (__s2_len <= 3) goto <D.43761>; else goto <D.43762>;
      <D.43761>:
      {
        const unsigned char * __s2;
        int __result;

        D.43755 = cfg->method;
        __s2 = D.43755->name;
        D.43763 = "FastMonitorEnterV4";
        D.43764 = MEM[(const unsigned char *)D.43763];
        D.43765 = (int) D.43764;
        D.43766 = *__s2;
        D.43767 = (int) D.43766;
        __result = D.43765 - D.43767;
        {
          if (__s2_len != 0) goto <D.43768>; else goto <D.43769>;
          <D.43768>:
          if (__result == 0) goto <D.43770>; else goto <D.43771>;
          <D.43770>:
          D.43772 = &MEM[(void *)"FastMonitorEnterV4" + 1B];
          D.43773 = *D.43772;
          D.43774 = (int) D.43773;
          D.43775 = __s2 + 1;
          D.43776 = *D.43775;
          D.43777 = (int) D.43776;
          __result = D.43774 - D.43777;
          if (__s2_len > 1) goto <D.43778>; else goto <D.43779>;
          <D.43778>:
          if (__result == 0) goto <D.43780>; else goto <D.43781>;
          <D.43780>:
          D.43782 = &MEM[(void *)"FastMonitorEnterV4" + 2B];
          D.43783 = *D.43782;
          D.43784 = (int) D.43783;
          D.43785 = __s2 + 2;
          D.43786 = *D.43785;
          D.43787 = (int) D.43786;
          __result = D.43784 - D.43787;
          if (__s2_len > 2) goto <D.43788>; else goto <D.43789>;
          <D.43788>:
          if (__result == 0) goto <D.43790>; else goto <D.43791>;
          <D.43790>:
          D.43792 = &MEM[(void *)"FastMonitorEnterV4" + 3B];
          D.43793 = *D.43792;
          D.43794 = (int) D.43793;
          D.43795 = __s2 + 3;
          D.43796 = *D.43795;
          D.43797 = (int) D.43796;
          __result = D.43794 - D.43797;
          <D.43791>:
          <D.43789>:
          <D.43781>:
          <D.43779>:
          <D.43771>:
          <D.43769>:
        }
        D.27123 = __result;
      }
      iftmp.379 = -D.27123;
      goto <D.43798>;
      <D.43762>:
      D.43755 = cfg->method;
      D.43799 = D.43755->name;
      iftmp.379 = __builtin_strcmp (D.43799, "FastMonitorEnterV4");
      <D.43798>:
      D.27124 = iftmp.379;
    }
    if (D.27124 == 0) goto <D.43800>; else goto <D.43801>;
    <D.43800>:
    D.42736 = 0B;
    return D.42736;
    <D.43801>:
    <D.43759>:
    fast_method = mono_monitor_get_fast_path (cmethod);
    if (fast_method == 0B) goto <D.43802>; else goto <D.43803>;
    <D.43802>:
    D.42736 = 0B;
    return D.42736;
    <D.43803>:
    D.42736 = mono_emit_method_call (cfg, fast_method, args, 0B);
    return D.42736;
  }
  <D.43754>:
  <D.43751>:
  {
    struct MonoMethod * fast_method;

    fast_method = 0B;
    D.43755 = cfg->method;
    D.43756 = BIT_FIELD_REF <*D.43755, 64, 256>;
    D.43757 = D.43756 & 124;
    if (D.43757 == 100) goto <D.43806>; else goto <D.43807>;
    <D.43806>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 16;
      if (__s2_len <= 3) goto <D.43809>; else goto <D.43810>;
      <D.43809>:
      {
        const unsigned char * __s2;
        int __result;

        D.43755 = cfg->method;
        __s2 = D.43755->name;
        D.43811 = "FastMonitorEnter";
        D.43812 = MEM[(const unsigned char *)D.43811];
        D.43813 = (int) D.43812;
        D.43814 = *__s2;
        D.43815 = (int) D.43814;
        __result = D.43813 - D.43815;
        {
          if (__s2_len != 0) goto <D.43816>; else goto <D.43817>;
          <D.43816>:
          if (__result == 0) goto <D.43818>; else goto <D.43819>;
          <D.43818>:
          D.43820 = &MEM[(void *)"FastMonitorEnter" + 1B];
          D.43821 = *D.43820;
          D.43822 = (int) D.43821;
          D.43823 = __s2 + 1;
          D.43824 = *D.43823;
          D.43825 = (int) D.43824;
          __result = D.43822 - D.43825;
          if (__s2_len > 1) goto <D.43826>; else goto <D.43827>;
          <D.43826>:
          if (__result == 0) goto <D.43828>; else goto <D.43829>;
          <D.43828>:
          D.43830 = &MEM[(void *)"FastMonitorEnter" + 2B];
          D.43831 = *D.43830;
          D.43832 = (int) D.43831;
          D.43833 = __s2 + 2;
          D.43834 = *D.43833;
          D.43835 = (int) D.43834;
          __result = D.43832 - D.43835;
          if (__s2_len > 2) goto <D.43836>; else goto <D.43837>;
          <D.43836>:
          if (__result == 0) goto <D.43838>; else goto <D.43839>;
          <D.43838>:
          D.43840 = &MEM[(void *)"FastMonitorEnter" + 3B];
          D.43841 = *D.43840;
          D.43842 = (int) D.43841;
          D.43843 = __s2 + 3;
          D.43844 = *D.43843;
          D.43845 = (int) D.43844;
          __result = D.43842 - D.43845;
          <D.43839>:
          <D.43837>:
          <D.43829>:
          <D.43827>:
          <D.43819>:
          <D.43817>:
        }
        D.27133 = __result;
      }
      iftmp.380 = -D.27133;
      goto <D.43846>;
      <D.43810>:
      D.43755 = cfg->method;
      D.43799 = D.43755->name;
      iftmp.380 = __builtin_strcmp (D.43799, "FastMonitorEnter");
      <D.43846>:
      D.27134 = iftmp.380;
    }
    if (D.27134 == 0) goto <D.43804>; else goto <D.43847>;
    <D.43847>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 15;
      if (__s2_len <= 3) goto <D.43849>; else goto <D.43850>;
      <D.43849>:
      {
        const unsigned char * __s2;
        int __result;

        D.43755 = cfg->method;
        __s2 = D.43755->name;
        D.43851 = "FastMonitorExit";
        D.43852 = MEM[(const unsigned char *)D.43851];
        D.43853 = (int) D.43852;
        D.43854 = *__s2;
        D.43855 = (int) D.43854;
        __result = D.43853 - D.43855;
        {
          if (__s2_len != 0) goto <D.43856>; else goto <D.43857>;
          <D.43856>:
          if (__result == 0) goto <D.43858>; else goto <D.43859>;
          <D.43858>:
          D.43860 = &MEM[(void *)"FastMonitorExit" + 1B];
          D.43861 = *D.43860;
          D.43862 = (int) D.43861;
          D.43863 = __s2 + 1;
          D.43864 = *D.43863;
          D.43865 = (int) D.43864;
          __result = D.43862 - D.43865;
          if (__s2_len > 1) goto <D.43866>; else goto <D.43867>;
          <D.43866>:
          if (__result == 0) goto <D.43868>; else goto <D.43869>;
          <D.43868>:
          D.43870 = &MEM[(void *)"FastMonitorExit" + 2B];
          D.43871 = *D.43870;
          D.43872 = (int) D.43871;
          D.43873 = __s2 + 2;
          D.43874 = *D.43873;
          D.43875 = (int) D.43874;
          __result = D.43872 - D.43875;
          if (__s2_len > 2) goto <D.43876>; else goto <D.43877>;
          <D.43876>:
          if (__result == 0) goto <D.43878>; else goto <D.43879>;
          <D.43878>:
          D.43880 = &MEM[(void *)"FastMonitorExit" + 3B];
          D.43881 = *D.43880;
          D.43882 = (int) D.43881;
          D.43883 = __s2 + 3;
          D.43884 = *D.43883;
          D.43885 = (int) D.43884;
          __result = D.43882 - D.43885;
          <D.43879>:
          <D.43877>:
          <D.43869>:
          <D.43867>:
          <D.43859>:
          <D.43857>:
        }
        D.27142 = __result;
      }
      iftmp.381 = -D.27142;
      goto <D.43886>;
      <D.43850>:
      D.43755 = cfg->method;
      D.43799 = D.43755->name;
      iftmp.381 = __builtin_strcmp (D.43799, "FastMonitorExit");
      <D.43886>:
      D.27143 = iftmp.381;
    }
    if (D.27143 == 0) goto <D.43804>; else goto <D.43805>;
    <D.43804>:
    D.42736 = 0B;
    return D.42736;
    <D.43805>:
    <D.43807>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.43891>; else goto <D.43892>;
      <D.43891>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = cmethod->name;
        D.43714 = "Enter";
        D.43715 = MEM[(const unsigned char *)D.43714];
        D.43716 = (int) D.43715;
        D.43893 = *__s2;
        D.43894 = (int) D.43893;
        __result = D.43716 - D.43894;
        {
          if (__s2_len != 0) goto <D.43895>; else goto <D.43896>;
          <D.43895>:
          if (__result == 0) goto <D.43897>; else goto <D.43898>;
          <D.43897>:
          D.43723 = &MEM[(void *)"Enter" + 1B];
          D.43724 = *D.43723;
          D.43725 = (int) D.43724;
          D.43899 = __s2 + 1;
          D.43900 = *D.43899;
          D.43901 = (int) D.43900;
          __result = D.43725 - D.43901;
          if (__s2_len > 1) goto <D.43902>; else goto <D.43903>;
          <D.43902>:
          if (__result == 0) goto <D.43904>; else goto <D.43905>;
          <D.43904>:
          D.43733 = &MEM[(void *)"Enter" + 2B];
          D.43734 = *D.43733;
          D.43735 = (int) D.43734;
          D.43906 = __s2 + 2;
          D.43907 = *D.43906;
          D.43908 = (int) D.43907;
          __result = D.43735 - D.43908;
          if (__s2_len > 2) goto <D.43909>; else goto <D.43910>;
          <D.43909>:
          if (__result == 0) goto <D.43911>; else goto <D.43912>;
          <D.43911>:
          D.43743 = &MEM[(void *)"Enter" + 3B];
          D.43744 = *D.43743;
          D.43745 = (int) D.43744;
          D.43913 = __s2 + 3;
          D.43914 = *D.43913;
          D.43915 = (int) D.43914;
          __result = D.43745 - D.43915;
          <D.43912>:
          <D.43910>:
          <D.43905>:
          <D.43903>:
          <D.43898>:
          <D.43896>:
        }
        D.27151 = __result;
      }
      iftmp.382 = -D.27151;
      goto <D.43916>;
      <D.43892>:
      D.42503 = cmethod->name;
      iftmp.382 = __builtin_strcmp (D.42503, "Enter");
      <D.43916>:
      D.27152 = iftmp.382;
    }
    if (D.27152 == 0) goto <D.43917>; else goto <D.43887>;
    <D.43917>:
    D.43752 = fsig->param_count;
    if (D.43752 == 2) goto <D.43888>; else goto <D.43887>;
    <D.43887>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 4;
      if (__s2_len <= 3) goto <D.43919>; else goto <D.43920>;
      <D.43919>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = cmethod->name;
        D.43921 = "Exit";
        D.43922 = MEM[(const unsigned char *)D.43921];
        D.43923 = (int) D.43922;
        D.43924 = *__s2;
        D.43925 = (int) D.43924;
        __result = D.43923 - D.43925;
        {
          if (__s2_len != 0) goto <D.43926>; else goto <D.43927>;
          <D.43926>:
          if (__result == 0) goto <D.43928>; else goto <D.43929>;
          <D.43928>:
          D.43930 = &MEM[(void *)"Exit" + 1B];
          D.43931 = *D.43930;
          D.43932 = (int) D.43931;
          D.43933 = __s2 + 1;
          D.43934 = *D.43933;
          D.43935 = (int) D.43934;
          __result = D.43932 - D.43935;
          if (__s2_len > 1) goto <D.43936>; else goto <D.43937>;
          <D.43936>:
          if (__result == 0) goto <D.43938>; else goto <D.43939>;
          <D.43938>:
          D.43940 = &MEM[(void *)"Exit" + 2B];
          D.43941 = *D.43940;
          D.43942 = (int) D.43941;
          D.43943 = __s2 + 2;
          D.43944 = *D.43943;
          D.43945 = (int) D.43944;
          __result = D.43942 - D.43945;
          if (__s2_len > 2) goto <D.43946>; else goto <D.43947>;
          <D.43946>:
          if (__result == 0) goto <D.43948>; else goto <D.43949>;
          <D.43948>:
          D.43950 = &MEM[(void *)"Exit" + 3B];
          D.43951 = *D.43950;
          D.43952 = (int) D.43951;
          D.43953 = __s2 + 3;
          D.43954 = *D.43953;
          D.43955 = (int) D.43954;
          __result = D.43952 - D.43955;
          <D.43949>:
          <D.43947>:
          <D.43939>:
          <D.43937>:
          <D.43929>:
          <D.43927>:
        }
        D.27160 = __result;
      }
      iftmp.383 = -D.27160;
      goto <D.43956>;
      <D.43920>:
      D.42503 = cmethod->name;
      iftmp.383 = __builtin_strcmp (D.42503, "Exit");
      <D.43956>:
      D.27161 = iftmp.383;
    }
    if (D.27161 == 0) goto <D.43888>; else goto <D.43889>;
    <D.43888>:
    fast_method = mono_monitor_get_fast_path (cmethod);
    <D.43889>:
    if (fast_method == 0B) goto <D.43957>; else goto <D.43958>;
    <D.43957>:
    D.42736 = 0B;
    return D.42736;
    <D.43958>:
    D.42736 = mono_emit_method_call (cfg, fast_method, args, 0B);
    return D.42736;
  }
  <D.43710>:
  D.42460 = cmethod->klass;
  D.43961 = D.42460->image;
  D.42458 = mono_defaults.corlib;
  if (D.43961 == D.42458) goto <D.43962>; else goto <D.43959>;
  <D.43962>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 16;
    if (__s2_len <= 3) goto <D.43964>; else goto <D.43965>;
    <D.43964>:
    {
      const unsigned char * __s2;
      int __result;

      D.42460 = cmethod->klass;
      __s2 = D.42460->name_space;
      D.43966 = "System.Threading";
      D.43967 = MEM[(const unsigned char *)D.43966];
      D.43968 = (int) D.43967;
      D.43969 = *__s2;
      D.43970 = (int) D.43969;
      __result = D.43968 - D.43970;
      {
        if (__s2_len != 0) goto <D.43971>; else goto <D.43972>;
        <D.43971>:
        if (__result == 0) goto <D.43973>; else goto <D.43974>;
        <D.43973>:
        D.43975 = &MEM[(void *)"System.Threading" + 1B];
        D.43976 = *D.43975;
        D.43977 = (int) D.43976;
        D.43978 = __s2 + 1;
        D.43979 = *D.43978;
        D.43980 = (int) D.43979;
        __result = D.43977 - D.43980;
        if (__s2_len > 1) goto <D.43981>; else goto <D.43982>;
        <D.43981>:
        if (__result == 0) goto <D.43983>; else goto <D.43984>;
        <D.43983>:
        D.43985 = &MEM[(void *)"System.Threading" + 2B];
        D.43986 = *D.43985;
        D.43987 = (int) D.43986;
        D.43988 = __s2 + 2;
        D.43989 = *D.43988;
        D.43990 = (int) D.43989;
        __result = D.43987 - D.43990;
        if (__s2_len > 2) goto <D.43991>; else goto <D.43992>;
        <D.43991>:
        if (__result == 0) goto <D.43993>; else goto <D.43994>;
        <D.43993>:
        D.43995 = &MEM[(void *)"System.Threading" + 3B];
        D.43996 = *D.43995;
        D.43997 = (int) D.43996;
        D.43998 = __s2 + 3;
        D.43999 = *D.43998;
        D.44000 = (int) D.43999;
        __result = D.43997 - D.44000;
        <D.43994>:
        <D.43992>:
        <D.43984>:
        <D.43982>:
        <D.43974>:
        <D.43972>:
      }
      D.27169 = __result;
    }
    iftmp.384 = -D.27169;
    goto <D.44001>;
    <D.43965>:
    D.42460 = cmethod->klass;
    D.44002 = D.42460->name_space;
    iftmp.384 = __builtin_strcmp (D.44002, "System.Threading");
    <D.44001>:
    D.27170 = iftmp.384;
  }
  if (D.27170 == 0) goto <D.44003>; else goto <D.43959>;
  <D.44003>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.44005>; else goto <D.44006>;
    <D.44005>:
    {
      const unsigned char * __s2;
      int __result;

      D.42460 = cmethod->klass;
      __s2 = D.42460->name;
      D.44007 = "Interlocked";
      D.44008 = MEM[(const unsigned char *)D.44007];
      D.44009 = (int) D.44008;
      D.44010 = *__s2;
      D.44011 = (int) D.44010;
      __result = D.44009 - D.44011;
      {
        if (__s2_len != 0) goto <D.44012>; else goto <D.44013>;
        <D.44012>:
        if (__result == 0) goto <D.44014>; else goto <D.44015>;
        <D.44014>:
        D.44016 = &MEM[(void *)"Interlocked" + 1B];
        D.44017 = *D.44016;
        D.44018 = (int) D.44017;
        D.44019 = __s2 + 1;
        D.44020 = *D.44019;
        D.44021 = (int) D.44020;
        __result = D.44018 - D.44021;
        if (__s2_len > 1) goto <D.44022>; else goto <D.44023>;
        <D.44022>:
        if (__result == 0) goto <D.44024>; else goto <D.44025>;
        <D.44024>:
        D.44026 = &MEM[(void *)"Interlocked" + 2B];
        D.44027 = *D.44026;
        D.44028 = (int) D.44027;
        D.44029 = __s2 + 2;
        D.44030 = *D.44029;
        D.44031 = (int) D.44030;
        __result = D.44028 - D.44031;
        if (__s2_len > 2) goto <D.44032>; else goto <D.44033>;
        <D.44032>:
        if (__result == 0) goto <D.44034>; else goto <D.44035>;
        <D.44034>:
        D.44036 = &MEM[(void *)"Interlocked" + 3B];
        D.44037 = *D.44036;
        D.44038 = (int) D.44037;
        D.44039 = __s2 + 3;
        D.44040 = *D.44039;
        D.44041 = (int) D.44040;
        __result = D.44038 - D.44041;
        <D.44035>:
        <D.44033>:
        <D.44025>:
        <D.44023>:
        <D.44015>:
        <D.44013>:
      }
      D.27178 = __result;
    }
    iftmp.385 = -D.27178;
    goto <D.44042>;
    <D.44006>:
    D.42460 = cmethod->klass;
    D.44043 = D.42460->name;
    iftmp.385 = __builtin_strcmp (D.44043, "Interlocked");
    <D.44042>:
    D.27179 = iftmp.385;
  }
  if (D.27179 == 0) goto <D.44044>; else goto <D.43959>;
  <D.44044>:
  ins = 0B;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.44046>; else goto <D.44047>;
    <D.44046>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44048 = "Read";
      D.44049 = MEM[(const unsigned char *)D.44048];
      D.44050 = (int) D.44049;
      D.44051 = *__s2;
      D.44052 = (int) D.44051;
      __result = D.44050 - D.44052;
      {
        if (__s2_len != 0) goto <D.44053>; else goto <D.44054>;
        <D.44053>:
        if (__result == 0) goto <D.44055>; else goto <D.44056>;
        <D.44055>:
        D.44057 = &MEM[(void *)"Read" + 1B];
        D.44058 = *D.44057;
        D.44059 = (int) D.44058;
        D.44060 = __s2 + 1;
        D.44061 = *D.44060;
        D.44062 = (int) D.44061;
        __result = D.44059 - D.44062;
        if (__s2_len > 1) goto <D.44063>; else goto <D.44064>;
        <D.44063>:
        if (__result == 0) goto <D.44065>; else goto <D.44066>;
        <D.44065>:
        D.44067 = &MEM[(void *)"Read" + 2B];
        D.44068 = *D.44067;
        D.44069 = (int) D.44068;
        D.44070 = __s2 + 2;
        D.44071 = *D.44070;
        D.44072 = (int) D.44071;
        __result = D.44069 - D.44072;
        if (__s2_len > 2) goto <D.44073>; else goto <D.44074>;
        <D.44073>:
        if (__result == 0) goto <D.44075>; else goto <D.44076>;
        <D.44075>:
        D.44077 = &MEM[(void *)"Read" + 3B];
        D.44078 = *D.44077;
        D.44079 = (int) D.44078;
        D.44080 = __s2 + 3;
        D.44081 = *D.44080;
        D.44082 = (int) D.44081;
        __result = D.44079 - D.44082;
        <D.44076>:
        <D.44074>:
        <D.44066>:
        <D.44064>:
        <D.44056>:
        <D.44054>:
      }
      D.27187 = __result;
    }
    iftmp.386 = -D.27187;
    goto <D.44083>;
    <D.44047>:
    D.42503 = cmethod->name;
    iftmp.386 = __builtin_strcmp (D.42503, "Read");
    <D.44083>:
    D.27188 = iftmp.386;
  }
  if (D.27188 == 0) goto <D.44084>; else goto <D.44085>;
  <D.44084>:
  D.44086 = fsig->params[0];
  D.44087 = D.44086->type;
  if (D.44087 == 10) goto <D.44088>; else goto <D.44089>;
  <D.44088>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 395;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  D.44090 = mono_alloc_preg (cfg);
  D.44091 = (int) D.44090;
  ins->dreg = D.44091;
  D.42539 = *args;
  D.42540 = D.42539->dreg;
  ins->sreg1 = D.42540;
  ins->data.op[0].const_val = 0;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.44092>; else goto <D.44093>;
  <D.44092>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.44094>;
  <D.44093>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.44094>:
  <D.44089>:
  <D.44085>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.44096>; else goto <D.44097>;
    <D.44096>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44098 = "Increment";
      D.44099 = MEM[(const unsigned char *)D.44098];
      D.44100 = (int) D.44099;
      D.44101 = *__s2;
      D.44102 = (int) D.44101;
      __result = D.44100 - D.44102;
      {
        if (__s2_len != 0) goto <D.44103>; else goto <D.44104>;
        <D.44103>:
        if (__result == 0) goto <D.44105>; else goto <D.44106>;
        <D.44105>:
        D.44107 = &MEM[(void *)"Increment" + 1B];
        D.44108 = *D.44107;
        D.44109 = (int) D.44108;
        D.44110 = __s2 + 1;
        D.44111 = *D.44110;
        D.44112 = (int) D.44111;
        __result = D.44109 - D.44112;
        if (__s2_len > 1) goto <D.44113>; else goto <D.44114>;
        <D.44113>:
        if (__result == 0) goto <D.44115>; else goto <D.44116>;
        <D.44115>:
        D.44117 = &MEM[(void *)"Increment" + 2B];
        D.44118 = *D.44117;
        D.44119 = (int) D.44118;
        D.44120 = __s2 + 2;
        D.44121 = *D.44120;
        D.44122 = (int) D.44121;
        __result = D.44119 - D.44122;
        if (__s2_len > 2) goto <D.44123>; else goto <D.44124>;
        <D.44123>:
        if (__result == 0) goto <D.44125>; else goto <D.44126>;
        <D.44125>:
        D.44127 = &MEM[(void *)"Increment" + 3B];
        D.44128 = *D.44127;
        D.44129 = (int) D.44128;
        D.44130 = __s2 + 3;
        D.44131 = *D.44130;
        D.44132 = (int) D.44131;
        __result = D.44129 - D.44132;
        <D.44126>:
        <D.44124>:
        <D.44116>:
        <D.44114>:
        <D.44106>:
        <D.44104>:
      }
      D.27196 = __result;
    }
    iftmp.387 = -D.27196;
    goto <D.44133>;
    <D.44097>:
    D.42503 = cmethod->name;
    iftmp.387 = __builtin_strcmp (D.42503, "Increment");
    <D.44133>:
    D.27197 = iftmp.387;
  }
  if (D.27197 == 0) goto <D.44134>; else goto <D.44135>;
  <D.44134>:
  {
    struct MonoInst * ins_iconst;
    guint32 opcode;

    opcode = 0;
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 8) goto <D.44136>; else goto <D.44137>;
    <D.44136>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.44138>;
    <D.44137>:
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 10) goto <D.44139>; else goto <D.44140>;
    <D.44139>:
    opcode = 809;
    <D.44140>:
    <D.44138>:
    if (opcode != 0) goto <D.44141>; else goto <D.44142>;
    <D.44141>:
    D.42510 = cfg->mempool;
    ins_iconst = mono_mempool_alloc (D.42510, 80);
    ins_iconst->data.op[1].const_val = 0;
    D.44143 = ins_iconst->data.op[1].const_val;
    ins_iconst->data.op[0].const_val = D.44143;
    ins_iconst->prev = 0B;
    D.44144 = ins_iconst->prev;
    ins_iconst->next = D.44144;
    ins_iconst->opcode = 362;
    ins_iconst->flags = 0;
    ins_iconst->type = 0;
    ins_iconst->dreg = -1;
    ins_iconst->sreg3 = -1;
    D.44145 = ins_iconst->sreg3;
    ins_iconst->sreg2 = D.44145;
    D.44146 = ins_iconst->sreg2;
    ins_iconst->sreg1 = D.44146;
    D.42515 = cfg->ip;
    ins_iconst->cil_code = D.42515;
    ins_iconst->data.op[0].const_val = 1;
    D.44147 = mono_alloc_ireg (cfg);
    D.44148 = (int) D.44147;
    ins_iconst->dreg = D.44148;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44149>; else goto <D.44150>;
    <D.44149>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins_iconst;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins_iconst->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins_iconst;
    goto <D.44151>;
    <D.44150>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins_iconst;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44151>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    D.44152 = (short unsigned int) opcode;
    ins->opcode = D.44152;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    D.44153 = mono_alloc_ireg (cfg);
    D.44154 = (int) D.44153;
    ins->dreg = D.44154;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    ins->data.op[0].const_val = 0;
    D.44155 = ins_iconst->dreg;
    ins->sreg2 = D.44155;
    if (opcode == 804) goto <D.44157>; else goto <D.44158>;
    <D.44157>:
    iftmp.388 = 1;
    goto <D.44159>;
    <D.44158>:
    iftmp.388 = 2;
    <D.44159>:
    ins->type = iftmp.388;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44160>; else goto <D.44161>;
    <D.44160>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.44162>;
    <D.44161>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44162>:
    <D.44142>:
  }
  goto <D.44163>;
  <D.44135>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.44165>; else goto <D.44166>;
    <D.44165>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44167 = "Decrement";
      D.44168 = MEM[(const unsigned char *)D.44167];
      D.44169 = (int) D.44168;
      D.44170 = *__s2;
      D.44171 = (int) D.44170;
      __result = D.44169 - D.44171;
      {
        if (__s2_len != 0) goto <D.44172>; else goto <D.44173>;
        <D.44172>:
        if (__result == 0) goto <D.44174>; else goto <D.44175>;
        <D.44174>:
        D.44176 = &MEM[(void *)"Decrement" + 1B];
        D.44177 = *D.44176;
        D.44178 = (int) D.44177;
        D.44179 = __s2 + 1;
        D.44180 = *D.44179;
        D.44181 = (int) D.44180;
        __result = D.44178 - D.44181;
        if (__s2_len > 1) goto <D.44182>; else goto <D.44183>;
        <D.44182>:
        if (__result == 0) goto <D.44184>; else goto <D.44185>;
        <D.44184>:
        D.44186 = &MEM[(void *)"Decrement" + 2B];
        D.44187 = *D.44186;
        D.44188 = (int) D.44187;
        D.44189 = __s2 + 2;
        D.44190 = *D.44189;
        D.44191 = (int) D.44190;
        __result = D.44188 - D.44191;
        if (__s2_len > 2) goto <D.44192>; else goto <D.44193>;
        <D.44192>:
        if (__result == 0) goto <D.44194>; else goto <D.44195>;
        <D.44194>:
        D.44196 = &MEM[(void *)"Decrement" + 3B];
        D.44197 = *D.44196;
        D.44198 = (int) D.44197;
        D.44199 = __s2 + 3;
        D.44200 = *D.44199;
        D.44201 = (int) D.44200;
        __result = D.44198 - D.44201;
        <D.44195>:
        <D.44193>:
        <D.44185>:
        <D.44183>:
        <D.44175>:
        <D.44173>:
      }
      D.27207 = __result;
    }
    iftmp.389 = -D.27207;
    goto <D.44202>;
    <D.44166>:
    D.42503 = cmethod->name;
    iftmp.389 = __builtin_strcmp (D.42503, "Decrement");
    <D.44202>:
    D.27208 = iftmp.389;
  }
  if (D.27208 == 0) goto <D.44203>; else goto <D.44204>;
  <D.44203>:
  {
    struct MonoInst * ins_iconst;
    guint32 opcode;

    opcode = 0;
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 8) goto <D.44205>; else goto <D.44206>;
    <D.44205>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.44207>;
    <D.44206>:
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 10) goto <D.44208>; else goto <D.44209>;
    <D.44208>:
    opcode = 809;
    <D.44209>:
    <D.44207>:
    if (opcode != 0) goto <D.44210>; else goto <D.44211>;
    <D.44210>:
    D.42510 = cfg->mempool;
    ins_iconst = mono_mempool_alloc (D.42510, 80);
    ins_iconst->data.op[1].const_val = 0;
    D.44212 = ins_iconst->data.op[1].const_val;
    ins_iconst->data.op[0].const_val = D.44212;
    ins_iconst->prev = 0B;
    D.44213 = ins_iconst->prev;
    ins_iconst->next = D.44213;
    ins_iconst->opcode = 362;
    ins_iconst->flags = 0;
    ins_iconst->type = 0;
    ins_iconst->dreg = -1;
    ins_iconst->sreg3 = -1;
    D.44214 = ins_iconst->sreg3;
    ins_iconst->sreg2 = D.44214;
    D.44215 = ins_iconst->sreg2;
    ins_iconst->sreg1 = D.44215;
    D.42515 = cfg->ip;
    ins_iconst->cil_code = D.42515;
    ins_iconst->data.op[0].const_val = -1;
    D.44216 = mono_alloc_ireg (cfg);
    D.44217 = (int) D.44216;
    ins_iconst->dreg = D.44217;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44218>; else goto <D.44219>;
    <D.44218>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins_iconst;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins_iconst->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins_iconst;
    goto <D.44220>;
    <D.44219>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins_iconst;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44220>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    D.44221 = (short unsigned int) opcode;
    ins->opcode = D.44221;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    D.44222 = mono_alloc_ireg (cfg);
    D.44223 = (int) D.44222;
    ins->dreg = D.44223;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    ins->data.op[0].const_val = 0;
    D.44224 = ins_iconst->dreg;
    ins->sreg2 = D.44224;
    if (opcode == 804) goto <D.44226>; else goto <D.44227>;
    <D.44226>:
    iftmp.390 = 1;
    goto <D.44228>;
    <D.44227>:
    iftmp.390 = 2;
    <D.44228>:
    ins->type = iftmp.390;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44229>; else goto <D.44230>;
    <D.44229>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.44231>;
    <D.44230>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44231>:
    <D.44211>:
  }
  goto <D.44232>;
  <D.44204>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.44236 = "Add";
      D.44237 = MEM[(const unsigned char *)D.44236];
      D.44238 = (int) D.44237;
      D.44239 = *__s2;
      D.44240 = (int) D.44239;
      __result = D.44238 - D.44240;
      {
        if (__s2_len != 0) goto <D.44241>; else goto <D.44242>;
        <D.44241>:
        if (__result == 0) goto <D.44243>; else goto <D.44244>;
        <D.44243>:
        D.44245 = &MEM[(void *)"Add" + 1B];
        D.44246 = *D.44245;
        D.44247 = (int) D.44246;
        D.44248 = __s2 + 1;
        D.44249 = *D.44248;
        D.44250 = (int) D.44249;
        __result = D.44247 - D.44250;
        if (__s2_len > 1) goto <D.44251>; else goto <D.44252>;
        <D.44251>:
        if (__result == 0) goto <D.44253>; else goto <D.44254>;
        <D.44253>:
        D.44255 = &MEM[(void *)"Add" + 2B];
        D.44256 = *D.44255;
        D.44257 = (int) D.44256;
        D.44258 = __s2 + 2;
        D.44259 = *D.44258;
        D.44260 = (int) D.44259;
        __result = D.44257 - D.44260;
        if (__s2_len > 2) goto <D.44261>; else goto <D.44262>;
        <D.44261>:
        if (__result == 0) goto <D.44263>; else goto <D.44264>;
        <D.44263>:
        D.44265 = &MEM[(void *)"Add" + 3B];
        D.44266 = *D.44265;
        D.44267 = (int) D.44266;
        D.44268 = __s2 + 3;
        D.44269 = *D.44268;
        D.44270 = (int) D.44269;
        __result = D.44267 - D.44270;
        <D.44264>:
        <D.44262>:
        <D.44254>:
        <D.44252>:
        <D.44244>:
        <D.44242>:
      }
      D.27218 = __result;
    }
    iftmp.391 = -D.27218;
    goto <D.44271>;
    <D.44235>:
    D.42503 = cmethod->name;
    iftmp.391 = __builtin_strcmp (D.42503, "Add");
    <D.44271>:
    D.27219 = iftmp.391;
  }
  if (D.27219 == 0) goto <D.44272>; else goto <D.44273>;
  <D.44272>:
  {
    guint32 opcode;

    opcode = 0;
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 8) goto <D.44274>; else goto <D.44275>;
    <D.44274>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.44276>;
    <D.44275>:
    D.44086 = fsig->params[0];
    D.44087 = D.44086->type;
    if (D.44087 == 10) goto <D.44277>; else goto <D.44278>;
    <D.44277>:
    opcode = 809;
    <D.44278>:
    <D.44276>:
    if (opcode != 0) goto <D.44279>; else goto <D.44280>;
    <D.44279>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    D.44281 = (short unsigned int) opcode;
    ins->opcode = D.44281;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    D.44282 = mono_alloc_ireg (cfg);
    D.44283 = (int) D.44282;
    ins->dreg = D.44283;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    ins->data.op[0].const_val = 0;
    D.42516 = args + 8;
    D.42517 = *D.42516;
    D.42518 = D.42517->dreg;
    ins->sreg2 = D.42518;
    if (opcode == 804) goto <D.44285>; else goto <D.44286>;
    <D.44285>:
    iftmp.392 = 1;
    goto <D.44287>;
    <D.44286>:
    iftmp.392 = 2;
    <D.44287>:
    ins->type = iftmp.392;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44288>; else goto <D.44289>;
    <D.44288>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.44290>;
    <D.44289>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44290>:
    <D.44280>:
  }
  <D.44273>:
  <D.44232>:
  <D.44163>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 15;
    if (__s2_len <= 3) goto <D.44292>; else goto <D.44293>;
    <D.44292>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44294 = "CompareExchange";
      D.44295 = MEM[(const unsigned char *)D.44294];
      D.44296 = (int) D.44295;
      D.44297 = *__s2;
      D.44298 = (int) D.44297;
      __result = D.44296 - D.44298;
      {
        if (__s2_len != 0) goto <D.44299>; else goto <D.44300>;
        <D.44299>:
        if (__result == 0) goto <D.44301>; else goto <D.44302>;
        <D.44301>:
        D.44303 = &MEM[(void *)"CompareExchange" + 1B];
        D.44304 = *D.44303;
        D.44305 = (int) D.44304;
        D.44306 = __s2 + 1;
        D.44307 = *D.44306;
        D.44308 = (int) D.44307;
        __result = D.44305 - D.44308;
        if (__s2_len > 1) goto <D.44309>; else goto <D.44310>;
        <D.44309>:
        if (__result == 0) goto <D.44311>; else goto <D.44312>;
        <D.44311>:
        D.44313 = &MEM[(void *)"CompareExchange" + 2B];
        D.44314 = *D.44313;
        D.44315 = (int) D.44314;
        D.44316 = __s2 + 2;
        D.44317 = *D.44316;
        D.44318 = (int) D.44317;
        __result = D.44315 - D.44318;
        if (__s2_len > 2) goto <D.44319>; else goto <D.44320>;
        <D.44319>:
        if (__result == 0) goto <D.44321>; else goto <D.44322>;
        <D.44321>:
        D.44323 = &MEM[(void *)"CompareExchange" + 3B];
        D.44324 = *D.44323;
        D.44325 = (int) D.44324;
        D.44326 = __s2 + 3;
        D.44327 = *D.44326;
        D.44328 = (int) D.44327;
        __result = D.44325 - D.44328;
        <D.44322>:
        <D.44320>:
        <D.44312>:
        <D.44310>:
        <D.44302>:
        <D.44300>:
      }
      D.27228 = __result;
    }
    iftmp.393 = -D.27228;
    goto <D.44329>;
    <D.44293>:
    D.42503 = cmethod->name;
    iftmp.393 = __builtin_strcmp (D.42503, "CompareExchange");
    <D.44329>:
    D.27229 = iftmp.393;
  }
  if (D.27229 == 0) goto <D.44330>; else goto <D.44331>;
  <D.44330>:
  {
    int size;
    gboolean is_ref;

    size = 0;
    D.44332 = fsig->params[1];
    is_ref = mini_type_is_reference (cfg, D.44332);
    D.44332 = fsig->params[1];
    D.44333 = D.44332->type;
    if (D.44333 == 8) goto <D.44334>; else goto <D.44335>;
    <D.44334>:
    size = 4;
    goto <D.44336>;
    <D.44335>:
    if (is_ref != 0) goto <D.44337>; else goto <D.44340>;
    <D.44340>:
    D.44332 = fsig->params[1];
    D.44333 = D.44332->type;
    if (D.44333 == 24) goto <D.44337>; else goto <D.44338>;
    <D.44337>:
    size = 8;
    goto <D.44339>;
    <D.44338>:
    D.44332 = fsig->params[1];
    D.44333 = D.44332->type;
    if (D.44333 == 10) goto <D.44341>; else goto <D.44342>;
    <D.44341>:
    size = 8;
    <D.44342>:
    <D.44339>:
    <D.44336>:
    if (size == 4) goto <D.44343>; else goto <D.44344>;
    <D.44343>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 814;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    if (is_ref != 0) goto <D.44346>; else goto <D.44347>;
    <D.44346>:
    D.44348 = alloc_ireg_ref (cfg);
    iftmp.394 = (gint32) D.44348;
    goto <D.44349>;
    <D.44347>:
    D.44350 = alloc_ireg (cfg);
    iftmp.394 = (gint32) D.44350;
    <D.44349>:
    ins->dreg = iftmp.394;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    D.42516 = args + 8;
    D.42517 = *D.42516;
    D.42518 = D.42517->dreg;
    ins->sreg2 = D.42518;
    D.42845 = args + 16;
    D.42846 = *D.42845;
    D.42847 = D.42846->dreg;
    ins->sreg3 = D.42847;
    ins->type = 1;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44351>; else goto <D.44352>;
    <D.44351>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.44353>;
    <D.44352>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44353>:
    goto <D.44354>;
    <D.44344>:
    if (size == 8) goto <D.44355>; else goto <D.44356>;
    <D.44355>:
    D.42510 = cfg->mempool;
    ins = mono_mempool_alloc (D.42510, 80);
    ins->data.op[1].const_val = 0;
    D.42729 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.42729;
    ins->prev = 0B;
    D.42730 = ins->prev;
    ins->next = D.42730;
    ins->opcode = 815;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.42731 = ins->sreg3;
    ins->sreg2 = D.42731;
    D.42732 = ins->sreg2;
    ins->sreg1 = D.42732;
    D.42515 = cfg->ip;
    ins->cil_code = D.42515;
    if (is_ref != 0) goto <D.44358>; else goto <D.44359>;
    <D.44358>:
    D.44360 = alloc_ireg_ref (cfg);
    iftmp.395 = (gint32) D.44360;
    goto <D.44361>;
    <D.44359>:
    D.44362 = alloc_ireg (cfg);
    iftmp.395 = (gint32) D.44362;
    <D.44361>:
    ins->dreg = iftmp.395;
    D.42539 = *args;
    D.42540 = D.42539->dreg;
    ins->sreg1 = D.42540;
    D.42516 = args + 8;
    D.42517 = *D.42516;
    D.42518 = D.42517->dreg;
    ins->sreg2 = D.42518;
    D.42845 = args + 16;
    D.42846 = *D.42845;
    D.42847 = D.42846->dreg;
    ins->sreg3 = D.42847;
    ins->type = 2;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    if (D.42520 != 0B) goto <D.44363>; else goto <D.44364>;
    <D.44363>:
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    D.42520->next = ins;
    D.42519 = cfg->cbb;
    D.42520 = D.42519->last_ins;
    ins->prev = D.42520;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    goto <D.44365>;
    <D.44364>:
    D.42519 = cfg->cbb;
    D.42519 = cfg->cbb;
    D.42519->last_ins = ins;
    D.42520 = D.42519->last_ins;
    D.42519->code = D.42520;
    <D.44365>:
    goto <D.44366>;
    <D.44356>:
    <D.44366>:
    <D.44354>:
    D.43285 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44367 = D.43285 & 1152921504606846976;
    if (D.44367 != 0) goto <D.44368>; else goto <D.44369>;
    <D.44368>:
    if (is_ref != 0) goto <D.44370>; else goto <D.44371>;
    <D.44370>:
    D.42539 = *args;
    D.42516 = args + 8;
    D.42517 = *D.42516;
    emit_write_barrier (cfg, D.42539, D.42517);
    <D.44371>:
    <D.44369>:
  }
  <D.44331>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 13;
    if (__s2_len <= 3) goto <D.44373>; else goto <D.44374>;
    <D.44373>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.43669 = "MemoryBarrier";
      D.43670 = MEM[(const unsigned char *)D.43669];
      D.43671 = (int) D.43670;
      D.44375 = *__s2;
      D.44376 = (int) D.44375;
      __result = D.43671 - D.44376;
      {
        if (__s2_len != 0) goto <D.44377>; else goto <D.44378>;
        <D.44377>:
        if (__result == 0) goto <D.44379>; else goto <D.44380>;
        <D.44379>:
        D.43678 = &MEM[(void *)"MemoryBarrier" + 1B];
        D.43679 = *D.43678;
        D.43680 = (int) D.43679;
        D.44381 = __s2 + 1;
        D.44382 = *D.44381;
        D.44383 = (int) D.44382;
        __result = D.43680 - D.44383;
        if (__s2_len > 1) goto <D.44384>; else goto <D.44385>;
        <D.44384>:
        if (__result == 0) goto <D.44386>; else goto <D.44387>;
        <D.44386>:
        D.43688 = &MEM[(void *)"MemoryBarrier" + 2B];
        D.43689 = *D.43688;
        D.43690 = (int) D.43689;
        D.44388 = __s2 + 2;
        D.44389 = *D.44388;
        D.44390 = (int) D.44389;
        __result = D.43690 - D.44390;
        if (__s2_len > 2) goto <D.44391>; else goto <D.44392>;
        <D.44391>:
        if (__result == 0) goto <D.44393>; else goto <D.44394>;
        <D.44393>:
        D.43698 = &MEM[(void *)"MemoryBarrier" + 3B];
        D.43699 = *D.43698;
        D.43700 = (int) D.43699;
        D.44395 = __s2 + 3;
        D.44396 = *D.44395;
        D.44397 = (int) D.44396;
        __result = D.43700 - D.44397;
        <D.44394>:
        <D.44392>:
        <D.44387>:
        <D.44385>:
        <D.44380>:
        <D.44378>:
      }
      D.27239 = __result;
    }
    iftmp.396 = -D.27239;
    goto <D.44398>;
    <D.44374>:
    D.42503 = cmethod->name;
    iftmp.396 = __builtin_strcmp (D.42503, "MemoryBarrier");
    <D.44398>:
    D.27240 = iftmp.396;
  }
  if (D.27240 == 0) goto <D.44399>; else goto <D.44400>;
  <D.44399>:
  ins = emit_memory_barrier (cfg, 4);
  <D.44400>:
  if (ins != 0B) goto <D.44401>; else goto <D.44402>;
  <D.44401>:
  D.42736 = ins;
  return D.42736;
  <D.44402>:
  goto <D.43960>;
  <D.43959>:
  D.42460 = cmethod->klass;
  D.43961 = D.42460->image;
  D.42458 = mono_defaults.corlib;
  if (D.43961 == D.42458) goto <D.44403>; else goto <D.44404>;
  <D.44403>:
  D.42503 = cmethod->name;
  D.43075 = *D.42503;
  if (D.43075 == 66) goto <D.44405>; else goto <D.44406>;
  <D.44405>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.44408>; else goto <D.44409>;
    <D.44408>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44410 = "Break";
      D.44411 = MEM[(const unsigned char *)D.44410];
      D.44412 = (int) D.44411;
      D.44413 = *__s2;
      D.44414 = (int) D.44413;
      __result = D.44412 - D.44414;
      {
        if (__s2_len != 0) goto <D.44415>; else goto <D.44416>;
        <D.44415>:
        if (__result == 0) goto <D.44417>; else goto <D.44418>;
        <D.44417>:
        D.44419 = &MEM[(void *)"Break" + 1B];
        D.44420 = *D.44419;
        D.44421 = (int) D.44420;
        D.44422 = __s2 + 1;
        D.44423 = *D.44422;
        D.44424 = (int) D.44423;
        __result = D.44421 - D.44424;
        if (__s2_len > 1) goto <D.44425>; else goto <D.44426>;
        <D.44425>:
        if (__result == 0) goto <D.44427>; else goto <D.44428>;
        <D.44427>:
        D.44429 = &MEM[(void *)"Break" + 2B];
        D.44430 = *D.44429;
        D.44431 = (int) D.44430;
        D.44432 = __s2 + 2;
        D.44433 = *D.44432;
        D.44434 = (int) D.44433;
        __result = D.44431 - D.44434;
        if (__s2_len > 2) goto <D.44435>; else goto <D.44436>;
        <D.44435>:
        if (__result == 0) goto <D.44437>; else goto <D.44438>;
        <D.44437>:
        D.44439 = &MEM[(void *)"Break" + 3B];
        D.44440 = *D.44439;
        D.44441 = (int) D.44440;
        D.44442 = __s2 + 3;
        D.44443 = *D.44442;
        D.44444 = (int) D.44443;
        __result = D.44441 - D.44444;
        <D.44438>:
        <D.44436>:
        <D.44428>:
        <D.44426>:
        <D.44418>:
        <D.44416>:
      }
      D.27248 = __result;
    }
    iftmp.397 = -D.27248;
    goto <D.44445>;
    <D.44409>:
    D.42503 = cmethod->name;
    iftmp.397 = __builtin_strcmp (D.42503, "Break");
    <D.44445>:
    D.27249 = iftmp.397;
  }
  if (D.27249 == 0) goto <D.44446>; else goto <D.44447>;
  <D.44446>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.42460 = cmethod->klass;
      __s2 = D.42460->name;
      D.44451 = "Debugger";
      D.44452 = MEM[(const unsigned char *)D.44451];
      D.44453 = (int) D.44452;
      D.44454 = *__s2;
      D.44455 = (int) D.44454;
      __result = D.44453 - D.44455;
      {
        if (__s2_len != 0) goto <D.44456>; else goto <D.44457>;
        <D.44456>:
        if (__result == 0) goto <D.44458>; else goto <D.44459>;
        <D.44458>:
        D.44460 = &MEM[(void *)"Debugger" + 1B];
        D.44461 = *D.44460;
        D.44462 = (int) D.44461;
        D.44463 = __s2 + 1;
        D.44464 = *D.44463;
        D.44465 = (int) D.44464;
        __result = D.44462 - D.44465;
        if (__s2_len > 1) goto <D.44466>; else goto <D.44467>;
        <D.44466>:
        if (__result == 0) goto <D.44468>; else goto <D.44469>;
        <D.44468>:
        D.44470 = &MEM[(void *)"Debugger" + 2B];
        D.44471 = *D.44470;
        D.44472 = (int) D.44471;
        D.44473 = __s2 + 2;
        D.44474 = *D.44473;
        D.44475 = (int) D.44474;
        __result = D.44472 - D.44475;
        if (__s2_len > 2) goto <D.44476>; else goto <D.44477>;
        <D.44476>:
        if (__result == 0) goto <D.44478>; else goto <D.44479>;
        <D.44478>:
        D.44480 = &MEM[(void *)"Debugger" + 3B];
        D.44481 = *D.44480;
        D.44482 = (int) D.44481;
        D.44483 = __s2 + 3;
        D.44484 = *D.44483;
        D.44485 = (int) D.44484;
        __result = D.44482 - D.44485;
        <D.44479>:
        <D.44477>:
        <D.44469>:
        <D.44467>:
        <D.44459>:
        <D.44457>:
      }
      D.27257 = __result;
    }
    iftmp.398 = -D.27257;
    goto <D.44486>;
    <D.44450>:
    D.42460 = cmethod->klass;
    D.44043 = D.42460->name;
    iftmp.398 = __builtin_strcmp (D.44043, "Debugger");
    <D.44486>:
    D.27258 = iftmp.398;
  }
  if (D.27258 == 0) goto <D.44487>; else goto <D.44488>;
  <D.44487>:
  D.43755 = cfg->method;
  D.44489 = should_insert_brekpoint (D.43755);
  if (D.44489 != 0) goto <D.44490>; else goto <D.44491>;
  <D.44490>:
  ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, 0B);
  goto <D.44492>;
  <D.44491>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.44493>; else goto <D.44494>;
  <D.44493>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.44495>;
  <D.44494>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.44495>:
  <D.44492>:
  D.42736 = ins;
  return D.42736;
  <D.44488>:
  <D.44447>:
  <D.44406>:
  D.42503 = cmethod->name;
  D.43075 = *D.42503;
  if (D.43075 == 103) goto <D.44496>; else goto <D.44497>;
  <D.44496>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 22;
    if (__s2_len <= 3) goto <D.44499>; else goto <D.44500>;
    <D.44499>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44501 = "get_IsRunningOnWindows";
      D.44502 = MEM[(const unsigned char *)D.44501];
      D.44503 = (int) D.44502;
      D.44504 = *__s2;
      D.44505 = (int) D.44504;
      __result = D.44503 - D.44505;
      {
        if (__s2_len != 0) goto <D.44506>; else goto <D.44507>;
        <D.44506>:
        if (__result == 0) goto <D.44508>; else goto <D.44509>;
        <D.44508>:
        D.44510 = &MEM[(void *)"get_IsRunningOnWindows" + 1B];
        D.44511 = *D.44510;
        D.44512 = (int) D.44511;
        D.44513 = __s2 + 1;
        D.44514 = *D.44513;
        D.44515 = (int) D.44514;
        __result = D.44512 - D.44515;
        if (__s2_len > 1) goto <D.44516>; else goto <D.44517>;
        <D.44516>:
        if (__result == 0) goto <D.44518>; else goto <D.44519>;
        <D.44518>:
        D.44520 = &MEM[(void *)"get_IsRunningOnWindows" + 2B];
        D.44521 = *D.44520;
        D.44522 = (int) D.44521;
        D.44523 = __s2 + 2;
        D.44524 = *D.44523;
        D.44525 = (int) D.44524;
        __result = D.44522 - D.44525;
        if (__s2_len > 2) goto <D.44526>; else goto <D.44527>;
        <D.44526>:
        if (__result == 0) goto <D.44528>; else goto <D.44529>;
        <D.44528>:
        D.44530 = &MEM[(void *)"get_IsRunningOnWindows" + 3B];
        D.44531 = *D.44530;
        D.44532 = (int) D.44531;
        D.44533 = __s2 + 3;
        D.44534 = *D.44533;
        D.44535 = (int) D.44534;
        __result = D.44532 - D.44535;
        <D.44529>:
        <D.44527>:
        <D.44519>:
        <D.44517>:
        <D.44509>:
        <D.44507>:
      }
      D.27266 = __result;
    }
    iftmp.399 = -D.27266;
    goto <D.44536>;
    <D.44500>:
    D.42503 = cmethod->name;
    iftmp.399 = __builtin_strcmp (D.42503, "get_IsRunningOnWindows");
    <D.44536>:
    D.27267 = iftmp.399;
  }
  if (D.27267 == 0) goto <D.44537>; else goto <D.44538>;
  <D.44537>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.44540>; else goto <D.44541>;
    <D.44540>:
    {
      const unsigned char * __s2;
      int __result;

      D.42460 = cmethod->klass;
      __s2 = D.42460->name;
      D.44542 = "Environment";
      D.44543 = MEM[(const unsigned char *)D.44542];
      D.44544 = (int) D.44543;
      D.44545 = *__s2;
      D.44546 = (int) D.44545;
      __result = D.44544 - D.44546;
      {
        if (__s2_len != 0) goto <D.44547>; else goto <D.44548>;
        <D.44547>:
        if (__result == 0) goto <D.44549>; else goto <D.44550>;
        <D.44549>:
        D.44551 = &MEM[(void *)"Environment" + 1B];
        D.44552 = *D.44551;
        D.44553 = (int) D.44552;
        D.44554 = __s2 + 1;
        D.44555 = *D.44554;
        D.44556 = (int) D.44555;
        __result = D.44553 - D.44556;
        if (__s2_len > 1) goto <D.44557>; else goto <D.44558>;
        <D.44557>:
        if (__result == 0) goto <D.44559>; else goto <D.44560>;
        <D.44559>:
        D.44561 = &MEM[(void *)"Environment" + 2B];
        D.44562 = *D.44561;
        D.44563 = (int) D.44562;
        D.44564 = __s2 + 2;
        D.44565 = *D.44564;
        D.44566 = (int) D.44565;
        __result = D.44563 - D.44566;
        if (__s2_len > 2) goto <D.44567>; else goto <D.44568>;
        <D.44567>:
        if (__result == 0) goto <D.44569>; else goto <D.44570>;
        <D.44569>:
        D.44571 = &MEM[(void *)"Environment" + 3B];
        D.44572 = *D.44571;
        D.44573 = (int) D.44572;
        D.44574 = __s2 + 3;
        D.44575 = *D.44574;
        D.44576 = (int) D.44575;
        __result = D.44573 - D.44576;
        <D.44570>:
        <D.44568>:
        <D.44560>:
        <D.44558>:
        <D.44550>:
        <D.44548>:
      }
      D.27275 = __result;
    }
    iftmp.400 = -D.27275;
    goto <D.44577>;
    <D.44541>:
    D.42460 = cmethod->klass;
    D.44043 = D.42460->name;
    iftmp.400 = __builtin_strcmp (D.44043, "Environment");
    <D.44577>:
    D.27276 = iftmp.400;
  }
  if (D.27276 == 0) goto <D.44578>; else goto <D.44579>;
  <D.44578>:
  D.42510 = cfg->mempool;
  ins = mono_mempool_alloc (D.42510, 80);
  ins->data.op[1].const_val = 0;
  D.42729 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42729;
  ins->prev = 0B;
  D.42730 = ins->prev;
  ins->next = D.42730;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42731 = ins->sreg3;
  ins->sreg2 = D.42731;
  D.42732 = ins->sreg2;
  ins->sreg1 = D.42732;
  D.42515 = cfg->ip;
  ins->cil_code = D.42515;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.44580 = alloc_dreg (cfg, 1);
  D.44581 = (int) D.44580;
  ins->dreg = D.44581;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  if (D.42520 != 0B) goto <D.44582>; else goto <D.44583>;
  <D.44582>:
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  D.42520->next = ins;
  D.42519 = cfg->cbb;
  D.42520 = D.42519->last_ins;
  ins->prev = D.42520;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  goto <D.44584>;
  <D.44583>:
  D.42519 = cfg->cbb;
  D.42519 = cfg->cbb;
  D.42519->last_ins = ins;
  D.42520 = D.42519->last_ins;
  D.42519->code = D.42520;
  <D.44584>:
  D.42736 = ins;
  return D.42736;
  <D.44579>:
  <D.44538>:
  <D.44497>:
  goto <D.44585>;
  <D.44404>:
  D.42460 = cmethod->klass;
  D.44586 = mono_defaults.math_class;
  if (D.42460 == D.44586) goto <D.44587>; else goto <D.44588>;
  <D.44587>:
  goto <D.44589>;
  <D.44588>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.42460 = cmethod->klass;
      D.43961 = D.42460->image;
      D.44595 = D.43961->assembly;
      __s2 = D.44595->aname.name;
      D.44596 = "MonoMac";
      D.44597 = MEM[(const unsigned char *)D.44596];
      D.44598 = (int) D.44597;
      D.44599 = *__s2;
      D.44600 = (int) D.44599;
      __result = D.44598 - D.44600;
      {
        if (__s2_len != 0) goto <D.44601>; else goto <D.44602>;
        <D.44601>:
        if (__result == 0) goto <D.44603>; else goto <D.44604>;
        <D.44603>:
        D.44605 = &MEM[(void *)"MonoMac" + 1B];
        D.44606 = *D.44605;
        D.44607 = (int) D.44606;
        D.44608 = __s2 + 1;
        D.44609 = *D.44608;
        D.44610 = (int) D.44609;
        __result = D.44607 - D.44610;
        if (__s2_len > 1) goto <D.44611>; else goto <D.44612>;
        <D.44611>:
        if (__result == 0) goto <D.44613>; else goto <D.44614>;
        <D.44613>:
        D.44615 = &MEM[(void *)"MonoMac" + 2B];
        D.44616 = *D.44615;
        D.44617 = (int) D.44616;
        D.44618 = __s2 + 2;
        D.44619 = *D.44618;
        D.44620 = (int) D.44619;
        __result = D.44617 - D.44620;
        if (__s2_len > 2) goto <D.44621>; else goto <D.44622>;
        <D.44621>:
        if (__result == 0) goto <D.44623>; else goto <D.44624>;
        <D.44623>:
        D.44625 = &MEM[(void *)"MonoMac" + 3B];
        D.44626 = *D.44625;
        D.44627 = (int) D.44626;
        D.44628 = __s2 + 3;
        D.44629 = *D.44628;
        D.44630 = (int) D.44629;
        __result = D.44627 - D.44630;
        <D.44624>:
        <D.44622>:
        <D.44614>:
        <D.44612>:
        <D.44604>:
        <D.44602>:
      }
      D.27284 = __result;
    }
    iftmp.401 = -D.27284;
    goto <D.44631>;
    <D.44594>:
    D.42460 = cmethod->klass;
    D.43961 = D.42460->image;
    D.44595 = D.43961->assembly;
    D.44632 = D.44595->aname.name;
    iftmp.401 = __builtin_strcmp (D.44632, "MonoMac");
    <D.44631>:
    D.27285 = iftmp.401;
  }
  if (D.27285 == 0) goto <D.44590>; else goto <D.44633>;
  <D.44633>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.44635>; else goto <D.44636>;
    <D.44635>:
    {
      const unsigned char * __s2;
      int __result;

      D.42460 = cmethod->klass;
      D.43961 = D.42460->image;
      D.44595 = D.43961->assembly;
      __s2 = D.44595->aname.name;
      D.44637 = "monotouch";
      D.44638 = MEM[(const unsigned char *)D.44637];
      D.44639 = (int) D.44638;
      D.44640 = *__s2;
      D.44641 = (int) D.44640;
      __result = D.44639 - D.44641;
      {
        if (__s2_len != 0) goto <D.44642>; else goto <D.44643>;
        <D.44642>:
        if (__result == 0) goto <D.44644>; else goto <D.44645>;
        <D.44644>:
        D.44646 = &MEM[(void *)"monotouch" + 1B];
        D.44647 = *D.44646;
        D.44648 = (int) D.44647;
        D.44649 = __s2 + 1;
        D.44650 = *D.44649;
        D.44651 = (int) D.44650;
        __result = D.44648 - D.44651;
        if (__s2_len > 1) goto <D.44652>; else goto <D.44653>;
        <D.44652>:
        if (__result == 0) goto <D.44654>; else goto <D.44655>;
        <D.44654>:
        D.44656 = &MEM[(void *)"monotouch" + 2B];
        D.44657 = *D.44656;
        D.44658 = (int) D.44657;
        D.44659 = __s2 + 2;
        D.44660 = *D.44659;
        D.44661 = (int) D.44660;
        __result = D.44658 - D.44661;
        if (__s2_len > 2) goto <D.44662>; else goto <D.44663>;
        <D.44662>:
        if (__result == 0) goto <D.44664>; else goto <D.44665>;
        <D.44664>:
        D.44666 = &MEM[(void *)"monotouch" + 3B];
        D.44667 = *D.44666;
        D.44668 = (int) D.44667;
        D.44669 = __s2 + 3;
        D.44670 = *D.44669;
        D.44671 = (int) D.44670;
        __result = D.44668 - D.44671;
        <D.44665>:
        <D.44663>:
        <D.44655>:
        <D.44653>:
        <D.44645>:
        <D.44643>:
      }
      D.27293 = __result;
    }
    iftmp.402 = -D.27293;
    goto <D.44672>;
    <D.44636>:
    D.42460 = cmethod->klass;
    D.43961 = D.42460->image;
    D.44595 = D.43961->assembly;
    D.44632 = D.44595->aname.name;
    iftmp.402 = __builtin_strcmp (D.44632, "monotouch");
    <D.44672>:
    D.27294 = iftmp.402;
  }
  if (D.27294 == 0) goto <D.44590>; else goto <D.44591>;
  <D.44590>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.42460 = cmethod->klass;
      __s2 = D.42460->name;
      D.44676 = "Selector";
      D.44677 = MEM[(const unsigned char *)D.44676];
      D.44678 = (int) D.44677;
      D.44679 = *__s2;
      D.44680 = (int) D.44679;
      __result = D.44678 - D.44680;
      {
        if (__s2_len != 0) goto <D.44681>; else goto <D.44682>;
        <D.44681>:
        if (__result == 0) goto <D.44683>; else goto <D.44684>;
        <D.44683>:
        D.44685 = &MEM[(void *)"Selector" + 1B];
        D.44686 = *D.44685;
        D.44687 = (int) D.44686;
        D.44688 = __s2 + 1;
        D.44689 = *D.44688;
        D.44690 = (int) D.44689;
        __result = D.44687 - D.44690;
        if (__s2_len > 1) goto <D.44691>; else goto <D.44692>;
        <D.44691>:
        if (__result == 0) goto <D.44693>; else goto <D.44694>;
        <D.44693>:
        D.44695 = &MEM[(void *)"Selector" + 2B];
        D.44696 = *D.44695;
        D.44697 = (int) D.44696;
        D.44698 = __s2 + 2;
        D.44699 = *D.44698;
        D.44700 = (int) D.44699;
        __result = D.44697 - D.44700;
        if (__s2_len > 2) goto <D.44701>; else goto <D.44702>;
        <D.44701>:
        if (__result == 0) goto <D.44703>; else goto <D.44704>;
        <D.44703>:
        D.44705 = &MEM[(void *)"Selector" + 3B];
        D.44706 = *D.44705;
        D.44707 = (int) D.44706;
        D.44708 = __s2 + 3;
        D.44709 = *D.44708;
        D.44710 = (int) D.44709;
        __result = D.44707 - D.44710;
        <D.44704>:
        <D.44702>:
        <D.44694>:
        <D.44692>:
        <D.44684>:
        <D.44682>:
      }
      D.27302 = __result;
    }
    iftmp.403 = -D.27302;
    goto <D.44711>;
    <D.44675>:
    D.42460 = cmethod->klass;
    D.44043 = D.42460->name;
    iftmp.403 = __builtin_strcmp (D.44043, "Selector");
    <D.44711>:
    D.27303 = iftmp.403;
  }
  if (D.27303 == 0) goto <D.44712>; else goto <D.44713>;
  <D.44712>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.44715>; else goto <D.44716>;
    <D.44715>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.44717 = "GetHandle";
      D.44718 = MEM[(const unsigned char *)D.44717];
      D.44719 = (int) D.44718;
      D.44720 = *__s2;
      D.44721 = (int) D.44720;
      __result = D.44719 - D.44721;
      {
        if (__s2_len != 0) goto <D.44722>; else goto <D.44723>;
        <D.44722>:
        if (__result == 0) goto <D.44724>; else goto <D.44725>;
        <D.44724>:
        D.44726 = &MEM[(void *)"GetHandle" + 1B];
        D.44727 = *D.44726;
        D.44728 = (int) D.44727;
        D.44729 = __s2 + 1;
        D.44730 = *D.44729;
        D.44731 = (int) D.44730;
        __result = D.44728 - D.44731;
        if (__s2_len > 1) goto <D.44732>; else goto <D.44733>;
        <D.44732>:
        if (__result == 0) goto <D.44734>; else goto <D.44735>;
        <D.44734>:
        D.44736 = &MEM[(void *)"GetHandle" + 2B];
        D.44737 = *D.44736;
        D.44738 = (int) D.44737;
        D.44739 = __s2 + 2;
        D.44740 = *D.44739;
        D.44741 = (int) D.44740;
        __result = D.44738 - D.44741;
        if (__s2_len > 2) goto <D.44742>; else goto <D.44743>;
        <D.44742>:
        if (__result == 0) goto <D.44744>; else goto <D.44745>;
        <D.44744>:
        D.44746 = &MEM[(void *)"GetHandle" + 3B];
        D.44747 = *D.44746;
        D.44748 = (int) D.44747;
        D.44749 = __s2 + 3;
        D.44750 = *D.44749;
        D.44751 = (int) D.44750;
        __result = D.44748 - D.44751;
        <D.44745>:
        <D.44743>:
        <D.44735>:
        <D.44733>:
        <D.44725>:
        <D.44723>:
      }
      D.27311 = __result;
    }
    iftmp.404 = -D.27311;
    goto <D.44752>;
    <D.44716>:
    D.42503 = cmethod->name;
    iftmp.404 = __builtin_strcmp (D.42503, "GetHandle");
    <D.44752>:
    D.27312 = iftmp.404;
  }
  if (D.27312 == 0) goto <D.44753>; else goto <D.44754>;
  <D.44753>:
  D.43285 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.44755 = D.43285 & 274877906944;
  if (D.44755 != 0) goto <D.44756>; else goto <D.44757>;
  <D.44756>:
  D.42539 = *args;
  D.44758 = D.42539->opcode;
  if (D.44758 == 734) goto <D.44759>; else goto <D.44760>;
  <D.44760>:
  D.42539 = *args;
  D.44758 = D.42539->opcode;
  if (D.44758 == 732) goto <D.44761>; else goto <D.44762>;
  <D.44761>:
  <D.44762>:
  <D.44759>:
  <D.44757>:
  <D.44754>:
  <D.44713>:
  <D.44591>:
  <D.44589>:
  <D.44585>:
  <D.43960>:
  <D.43707>:
  if (0 != 0) goto <D.44763>; else goto <D.44764>;
  <D.44763>:
  ins = llvm_emit_inst_for_method (cfg, cmethod, fsig, args);
  if (ins != 0B) goto <D.44765>; else goto <D.44766>;
  <D.44765>:
  D.42736 = ins;
  return D.42736;
  <D.44766>:
  <D.44764>:
  D.42736 = mono_arch_emit_inst_for_method (cfg, cmethod, fsig, args);
  return D.42736;
}


emit_array_generic_access (struct MonoCompile * cfg, struct MonoMethodSignature * fsig, struct MonoInst * * args, int is_set)
{
  struct MonoType * D.44768;
  struct MonoInst * D.44769;
  struct MonoInst * * D.44770;
  struct MonoInst * D.44771;
  struct MonoMemPool * D.44774;
  long int D.44775;
  struct MonoInst * D.44776;
  struct MonoType * D.44777;
  unsigned int D.44778;
  short unsigned int D.44779;
  int D.44780;
  int D.44781;
  const unsigned char * D.44782;
  struct MonoInst * * D.44783;
  struct MonoInst * D.44784;
  int D.44785;
  unsigned char D.44786;
  <unnamed type> D.44787;
  unsigned int D.44788;
  int D.44789;
  struct MonoBasicBlock * D.44790;
  struct MonoInst * D.44791;
  long int D.44795;
  struct MonoInst * D.44796;
  unsigned int D.44797;
  short unsigned int D.44798;
  int D.44799;
  int D.44800;
  int D.44801;
  int D.44802;
  struct MonoClass * D.44803;
  int D.44807;
  unsigned int D.44811;
  short unsigned int D.44812;
  unsigned int D.44813;
  int D.44814;
  unsigned int D.44818;
  short unsigned int D.44819;
  struct MonoClass * D.44820;
  struct MonoInst * D.44824;
  struct MonoInst * addr;
  struct MonoInst * store;
  struct MonoInst * load;
  struct MonoClass * eklass;

  D.44768 = fsig->params[2];
  eklass = mono_class_from_mono_type (D.44768);
  D.44769 = *args;
  D.44770 = args + 8;
  D.44771 = *D.44770;
  addr = mini_emit_ldelema_1_ins (cfg, eklass, D.44769, D.44771, 0);
  if (is_set != 0) goto <D.44772>; else goto <D.44773>;
  <D.44772>:
  D.44774 = cfg->mempool;
  load = mono_mempool_alloc (D.44774, 80);
  load->data.op[1].const_val = 0;
  D.44775 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.44775;
  load->prev = 0B;
  D.44776 = load->prev;
  load->next = D.44776;
  D.44777 = &eklass->byval_arg;
  D.44778 = mono_type_to_load_membase (cfg, D.44777);
  D.44779 = (short unsigned int) D.44778;
  load->opcode = D.44779;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.44780 = load->sreg3;
  load->sreg2 = D.44780;
  D.44781 = load->sreg2;
  load->sreg1 = D.44781;
  D.44782 = cfg->ip;
  load->cil_code = D.44782;
  load->dreg = 0;
  D.44783 = args + 16;
  D.44784 = *D.44783;
  D.44785 = D.44784->dreg;
  load->sreg1 = D.44785;
  load->data.op[0].const_val = 0;
  load->type = 1;
  D.44777 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.44777, load);
  D.44786 = load->type;
  D.44787 = (<unnamed type>) D.44786;
  D.44788 = alloc_dreg (cfg, D.44787);
  D.44789 = (int) D.44788;
  load->dreg = D.44789;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  if (D.44791 != 0B) goto <D.44792>; else goto <D.44793>;
  <D.44792>:
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  D.44791->next = load;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  load->prev = D.44791;
  D.44790 = cfg->cbb;
  D.44790->last_ins = load;
  goto <D.44794>;
  <D.44793>:
  D.44790 = cfg->cbb;
  D.44790 = cfg->cbb;
  D.44790->last_ins = load;
  D.44791 = D.44790->last_ins;
  D.44790->code = D.44791;
  <D.44794>:
  D.44774 = cfg->mempool;
  store = mono_mempool_alloc (D.44774, 80);
  store->data.op[1].const_val = 0;
  D.44795 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.44795;
  store->prev = 0B;
  D.44796 = store->prev;
  store->next = D.44796;
  D.44777 = &eklass->byval_arg;
  D.44797 = mono_type_to_store_membase (cfg, D.44777);
  D.44798 = (short unsigned int) D.44797;
  store->opcode = D.44798;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.44799 = store->sreg3;
  store->sreg2 = D.44799;
  D.44800 = store->sreg2;
  store->sreg1 = D.44800;
  D.44782 = cfg->ip;
  store->cil_code = D.44782;
  D.44801 = load->dreg;
  store->sreg1 = D.44801;
  D.44802 = addr->dreg;
  store->dreg = D.44802;
  store->data.op[0].const_val = 0;
  D.44777 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.44777, store);
  D.44777 = &eklass->byval_arg;
  D.44803 = mono_class_from_mono_type (D.44777);
  store->klass = D.44803;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  if (D.44791 != 0B) goto <D.44804>; else goto <D.44805>;
  <D.44804>:
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  D.44791->next = store;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  store->prev = D.44791;
  D.44790 = cfg->cbb;
  D.44790->last_ins = store;
  goto <D.44806>;
  <D.44805>:
  D.44790 = cfg->cbb;
  D.44790 = cfg->cbb;
  D.44790->last_ins = store;
  D.44791 = D.44790->last_ins;
  D.44790->code = D.44791;
  <D.44806>:
  D.44768 = fsig->params[2];
  D.44807 = mini_type_is_reference (cfg, D.44768);
  if (D.44807 != 0) goto <D.44808>; else goto <D.44809>;
  <D.44808>:
  emit_write_barrier (cfg, addr, load);
  <D.44809>:
  goto <D.44810>;
  <D.44773>:
  D.44774 = cfg->mempool;
  load = mono_mempool_alloc (D.44774, 80);
  load->data.op[1].const_val = 0;
  D.44775 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.44775;
  load->prev = 0B;
  D.44776 = load->prev;
  load->next = D.44776;
  D.44777 = &eklass->byval_arg;
  D.44811 = mono_type_to_load_membase (cfg, D.44777);
  D.44812 = (short unsigned int) D.44811;
  load->opcode = D.44812;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.44780 = load->sreg3;
  load->sreg2 = D.44780;
  D.44781 = load->sreg2;
  load->sreg1 = D.44781;
  D.44782 = cfg->ip;
  load->cil_code = D.44782;
  load->dreg = 0;
  D.44802 = addr->dreg;
  load->sreg1 = D.44802;
  load->data.op[0].const_val = 0;
  load->type = 1;
  D.44777 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.44777, load);
  D.44786 = load->type;
  D.44787 = (<unnamed type>) D.44786;
  D.44813 = alloc_dreg (cfg, D.44787);
  D.44814 = (int) D.44813;
  load->dreg = D.44814;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  if (D.44791 != 0B) goto <D.44815>; else goto <D.44816>;
  <D.44815>:
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  D.44791->next = load;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  load->prev = D.44791;
  D.44790 = cfg->cbb;
  D.44790->last_ins = load;
  goto <D.44817>;
  <D.44816>:
  D.44790 = cfg->cbb;
  D.44790 = cfg->cbb;
  D.44790->last_ins = load;
  D.44791 = D.44790->last_ins;
  D.44790->code = D.44791;
  <D.44817>:
  D.44774 = cfg->mempool;
  store = mono_mempool_alloc (D.44774, 80);
  store->data.op[1].const_val = 0;
  D.44795 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.44795;
  store->prev = 0B;
  D.44796 = store->prev;
  store->next = D.44796;
  D.44777 = &eklass->byval_arg;
  D.44818 = mono_type_to_store_membase (cfg, D.44777);
  D.44819 = (short unsigned int) D.44818;
  store->opcode = D.44819;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.44799 = store->sreg3;
  store->sreg2 = D.44799;
  D.44800 = store->sreg2;
  store->sreg1 = D.44800;
  D.44782 = cfg->ip;
  store->cil_code = D.44782;
  D.44801 = load->dreg;
  store->sreg1 = D.44801;
  D.44783 = args + 16;
  D.44784 = *D.44783;
  D.44785 = D.44784->dreg;
  store->dreg = D.44785;
  store->data.op[0].const_val = 0;
  D.44777 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.44777, store);
  D.44777 = &eklass->byval_arg;
  D.44820 = mono_class_from_mono_type (D.44777);
  store->klass = D.44820;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  if (D.44791 != 0B) goto <D.44821>; else goto <D.44822>;
  <D.44821>:
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  D.44791->next = store;
  D.44790 = cfg->cbb;
  D.44791 = D.44790->last_ins;
  store->prev = D.44791;
  D.44790 = cfg->cbb;
  D.44790->last_ins = store;
  goto <D.44823>;
  <D.44822>:
  D.44790 = cfg->cbb;
  D.44790 = cfg->cbb;
  D.44790->last_ins = store;
  D.44791 = D.44790->last_ins;
  D.44790->code = D.44791;
  <D.44823>:
  <D.44810>:
  D.44824 = store;
  return D.44824;
}


emit_get_rgctx_sig (struct MonoCompile * cfg, int context_used, struct MonoMethodSignature * sig, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.44826;
  struct MonoMethod * D.44827;
  int D.44828;
  struct MonoInst * D.44829;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.44826 = cfg->mempool;
  D.44827 = cfg->current_method;
  D.44828 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.44826, D.44827, D.44828, 44, sig, rgctx_type);
  D.44827 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.44827, context_used);
  D.44829 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.44829;
}


mini_emit_ldelema_ins (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * sp, unsigned char * ip, gboolean is_set)
{
  struct MonoMethodSignature * D.44831;
  short unsigned int D.44832;
  int D.44833;
  _Bool D.44834;
  int D.44835;
  struct MonoInst * D.44838;
  struct MonoClass * D.44839;
  struct MonoClass * D.44840;
  struct MonoInst * D.44841;
  struct MonoInst * * D.44842;
  struct MonoInst * D.44843;
  unsigned int D.44846;
  unsigned int D.44847;
  struct MonoInst * * D.44850;
  struct MonoInst * D.44851;
  int rank;
  struct MonoInst * addr;
  struct MonoMethod * addr_method;
  int element_size;

  D.44831 = mono_method_signature (cmethod);
  D.44832 = D.44831->param_count;
  D.44833 = (int) D.44832;
  D.44834 = is_set != 0;
  D.44835 = (int) D.44834;
  rank = D.44833 - D.44835;
  if (rank == 1) goto <D.44836>; else goto <D.44837>;
  <D.44836>:
  D.44839 = cmethod->klass;
  D.44840 = D.44839->element_class;
  D.44841 = *sp;
  D.44842 = sp + 8;
  D.44843 = *D.44842;
  D.44838 = mini_emit_ldelema_1_ins (cfg, D.44840, D.44841, D.44843, 1);
  return D.44838;
  <D.44837>:
  if (rank == 2) goto <D.44844>; else goto <D.44845>;
  <D.44844>:
  D.44846 = cfg->opt;
  D.44847 = D.44846 & 2048;
  if (D.44847 != 0) goto <D.44848>; else goto <D.44849>;
  <D.44848>:
  D.44839 = cmethod->klass;
  D.44840 = D.44839->element_class;
  D.44841 = *sp;
  D.44842 = sp + 8;
  D.44843 = *D.44842;
  D.44850 = sp + 16;
  D.44851 = *D.44850;
  D.44838 = mini_emit_ldelema_2_ins (cfg, D.44840, D.44841, D.44843, D.44851);
  return D.44838;
  <D.44849>:
  <D.44845>:
  D.44839 = cmethod->klass;
  D.44840 = D.44839->element_class;
  element_size = mono_class_array_element_size (D.44840);
  addr_method = mono_marshal_get_array_address (rank, element_size);
  addr = mono_emit_method_call (cfg, addr_method, sp, 0B);
  D.44838 = addr;
  return D.44838;
}


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.44853;
  unsigned int D.44854;
  unsigned int D.44855;
  unsigned int D.44856;
  unsigned int D.44857;
  unsigned int D.44858;
  unsigned int D.44859;
  unsigned int D.44860;
  unsigned int D.44861;
  unsigned int D.44862;
  unsigned int D.44863;
  int D.44864;
  unsigned int D.44868;
  struct MonoMemPool * D.44869;
  long int D.44870;
  struct MonoInst * D.44871;
  int D.44872;
  int D.44873;
  const unsigned char * D.44874;
  struct MonoBasicBlock * D.44875;
  struct MonoInst * D.44876;
  unsigned int D.44880;
  long int D.44881;
  struct MonoInst * D.44882;
  int D.44883;
  int D.44884;
  long int D.44888;
  struct MonoInst * D.44889;
  int D.44890;
  int D.44891;
  int D.44892;
  long int D.44896;
  struct MonoInst * D.44897;
  int D.44898;
  int D.44899;
  long int D.44903;
  struct MonoInst * D.44904;
  int D.44905;
  int D.44906;
  long int D.44910;
  struct MonoInst * D.44911;
  int D.44912;
  int D.44913;
  long int D.44917;
  struct MonoInst * D.44918;
  int D.44919;
  int D.44920;
  long int D.44924;
  struct MonoInst * D.44925;
  int D.44926;
  int D.44927;
  long int D.44931;
  struct MonoInst * D.44932;
  int D.44933;
  int D.44934;
  long int D.44938;
  struct MonoInst * D.44939;
  int D.44940;
  int D.44941;
  long int D.44945;
  struct MonoInst * D.44946;
  int D.44947;
  int D.44948;
  long int D.44952;
  struct MonoInst * D.44953;
  int D.44954;
  int D.44955;
  long int D.44959;
  struct MonoInst * D.44960;
  int D.44961;
  int D.44962;
  long int D.44966;
  struct MonoInst * D.44967;
  int D.44968;
  int D.44969;
  long int D.44973;
  struct MonoInst * D.44974;
  int D.44975;
  int D.44976;
  long int D.44980;
  struct MonoInst * D.44981;
  int D.44982;
  int D.44983;
  long int D.44984;
  long int D.44988;
  struct MonoInst * D.44989;
  int D.44990;
  int D.44991;
  long int D.44995;
  struct MonoInst * D.44996;
  int D.44997;
  int D.44998;
  struct MonoInst * D.45002;
  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.44853 = alloc_preg (cfg);
  bounds_reg = (int) D.44853;
  D.44854 = alloc_ireg_mp (cfg);
  add_reg = (int) D.44854;
  D.44855 = alloc_preg (cfg);
  mult_reg = (int) D.44855;
  D.44856 = alloc_preg (cfg);
  mult2_reg = (int) D.44856;
  D.44857 = alloc_preg (cfg);
  low1_reg = (int) D.44857;
  D.44858 = alloc_preg (cfg);
  low2_reg = (int) D.44858;
  D.44859 = alloc_preg (cfg);
  high1_reg = (int) D.44859;
  D.44860 = alloc_preg (cfg);
  high2_reg = (int) D.44860;
  D.44861 = alloc_preg (cfg);
  realidx1_reg = (int) D.44861;
  D.44862 = alloc_preg (cfg);
  realidx2_reg = (int) D.44862;
  D.44863 = alloc_preg (cfg);
  sum_reg = (int) D.44863;
  mono_class_init (klass);
  D.44864 = mono_class_array_element_size (klass);
  size = (guint32) D.44864;
  index1 = index_ins1->dreg;
  index2 = index_ins2->dreg;
  if (0 != 0) goto <D.44865>; else goto <D.44866>;
  <D.44865>:
  goto <D.44867>;
  <D.44866>:
  D.44868 = alloc_preg (cfg);
  tmpreg = (int) D.44868;
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44870 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44870;
    inst->prev = 0B;
    D.44871 = inst->prev;
    inst->next = D.44871;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44872 = inst->sreg3;
    inst->sreg2 = D.44872;
    D.44873 = inst->sreg2;
    inst->sreg1 = D.44873;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = tmpreg;
    inst->sreg1 = index1;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44877>; else goto <D.44878>;
    <D.44877>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44879>;
    <D.44878>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44879>:
  }
  index1 = tmpreg;
  D.44880 = alloc_preg (cfg);
  tmpreg = (int) D.44880;
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44881 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44881;
    inst->prev = 0B;
    D.44882 = inst->prev;
    inst->next = D.44882;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44883 = inst->sreg3;
    inst->sreg2 = D.44883;
    D.44884 = inst->sreg2;
    inst->sreg1 = D.44884;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = tmpreg;
    inst->sreg1 = index2;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44885>; else goto <D.44886>;
    <D.44885>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44887>;
    <D.44886>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44887>:
  }
  index2 = tmpreg;
  <D.44867>:
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44888 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44888;
    inst->prev = 0B;
    D.44889 = inst->prev;
    inst->next = D.44889;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44890 = inst->sreg3;
    inst->sreg2 = D.44890;
    D.44891 = inst->sreg2;
    inst->sreg1 = D.44891;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = bounds_reg;
    D.44892 = arr->dreg;
    inst->sreg1 = D.44892;
    inst->data.op[0].const_val = 16;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44893>; else goto <D.44894>;
    <D.44893>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44895>;
    <D.44894>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44895>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44896 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44896;
    inst->prev = 0B;
    D.44897 = inst->prev;
    inst->next = D.44897;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44898 = inst->sreg3;
    inst->sreg2 = D.44898;
    D.44899 = inst->sreg2;
    inst->sreg1 = D.44899;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = low1_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 4;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44900>; else goto <D.44901>;
    <D.44900>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44902>;
    <D.44901>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44902>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44903 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44903;
    inst->prev = 0B;
    D.44904 = inst->prev;
    inst->next = D.44904;
    inst->opcode = 480;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44905 = inst->sreg3;
    inst->sreg2 = D.44905;
    D.44906 = inst->sreg2;
    inst->sreg1 = D.44906;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = realidx1_reg;
    inst->sreg1 = index1;
    inst->sreg2 = low1_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44907>; else goto <D.44908>;
    <D.44907>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44909>;
    <D.44908>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44909>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44910 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44910;
    inst->prev = 0B;
    D.44911 = inst->prev;
    inst->next = D.44911;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44912 = inst->sreg3;
    inst->sreg2 = D.44912;
    D.44913 = inst->sreg2;
    inst->sreg1 = D.44913;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = high1_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 0;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44914>; else goto <D.44915>;
    <D.44914>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44916>;
    <D.44915>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44916>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44917 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44917;
    inst->prev = 0B;
    D.44918 = inst->prev;
    inst->next = D.44918;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44919 = inst->sreg3;
    inst->sreg2 = D.44919;
    D.44920 = inst->sreg2;
    inst->sreg1 = D.44920;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = -1;
    inst->sreg1 = high1_reg;
    inst->sreg2 = realidx1_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44921>; else goto <D.44922>;
    <D.44921>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44923>;
    <D.44922>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44923>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44924 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44924;
    inst->prev = 0B;
    D.44925 = inst->prev;
    inst->next = D.44925;
    inst->opcode = 459;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44926 = inst->sreg3;
    inst->sreg2 = D.44926;
    D.44927 = inst->sreg2;
    inst->sreg1 = D.44927;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->data.op[1].p = "IndexOutOfRangeException";
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44928>; else goto <D.44929>;
    <D.44928>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44930>;
    <D.44929>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44930>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44931 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44931;
    inst->prev = 0B;
    D.44932 = inst->prev;
    inst->next = D.44932;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44933 = inst->sreg3;
    inst->sreg2 = D.44933;
    D.44934 = inst->sreg2;
    inst->sreg1 = D.44934;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = low2_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 12;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44935>; else goto <D.44936>;
    <D.44935>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44937>;
    <D.44936>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44937>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44938 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44938;
    inst->prev = 0B;
    D.44939 = inst->prev;
    inst->next = D.44939;
    inst->opcode = 480;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44940 = inst->sreg3;
    inst->sreg2 = D.44940;
    D.44941 = inst->sreg2;
    inst->sreg1 = D.44941;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = realidx2_reg;
    inst->sreg1 = index2;
    inst->sreg2 = low2_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44942>; else goto <D.44943>;
    <D.44942>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44944>;
    <D.44943>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44944>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44945 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44945;
    inst->prev = 0B;
    D.44946 = inst->prev;
    inst->next = D.44946;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44947 = inst->sreg3;
    inst->sreg2 = D.44947;
    D.44948 = inst->sreg2;
    inst->sreg1 = D.44948;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = high2_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 8;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44949>; else goto <D.44950>;
    <D.44949>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44951>;
    <D.44950>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44951>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44952 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44952;
    inst->prev = 0B;
    D.44953 = inst->prev;
    inst->next = D.44953;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44954 = inst->sreg3;
    inst->sreg2 = D.44954;
    D.44955 = inst->sreg2;
    inst->sreg1 = D.44955;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = -1;
    inst->sreg1 = high2_reg;
    inst->sreg2 = realidx2_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44956>; else goto <D.44957>;
    <D.44956>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44958>;
    <D.44957>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44958>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44959 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44959;
    inst->prev = 0B;
    D.44960 = inst->prev;
    inst->next = D.44960;
    inst->opcode = 459;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44961 = inst->sreg3;
    inst->sreg2 = D.44961;
    D.44962 = inst->sreg2;
    inst->sreg1 = D.44962;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->data.op[1].p = "IndexOutOfRangeException";
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44963>; else goto <D.44964>;
    <D.44963>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44965>;
    <D.44964>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44965>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44966 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44966;
    inst->prev = 0B;
    D.44967 = inst->prev;
    inst->next = D.44967;
    inst->opcode = 481;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44968 = inst->sreg3;
    inst->sreg2 = D.44968;
    D.44969 = inst->sreg2;
    inst->sreg1 = D.44969;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = mult_reg;
    inst->sreg1 = high2_reg;
    inst->sreg2 = realidx1_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44970>; else goto <D.44971>;
    <D.44970>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44972>;
    <D.44971>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44972>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44973 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44973;
    inst->prev = 0B;
    D.44974 = inst->prev;
    inst->next = D.44974;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44975 = inst->sreg3;
    inst->sreg2 = D.44975;
    D.44976 = inst->sreg2;
    inst->sreg1 = D.44976;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = sum_reg;
    inst->sreg1 = mult_reg;
    inst->sreg2 = realidx2_reg;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44977>; else goto <D.44978>;
    <D.44977>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44979>;
    <D.44978>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44979>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44980 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44980;
    inst->prev = 0B;
    D.44981 = inst->prev;
    inst->next = D.44981;
    inst->opcode = 540;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44982 = inst->sreg3;
    inst->sreg2 = D.44982;
    D.44983 = inst->sreg2;
    inst->sreg1 = D.44983;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = mult2_reg;
    inst->sreg1 = sum_reg;
    D.44984 = (long int) size;
    inst->data.op[1].const_val = D.44984;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44985>; else goto <D.44986>;
    <D.44985>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44987>;
    <D.44986>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44987>:
  }
  {
    struct MonoInst * inst;

    D.44869 = cfg->mempool;
    inst = mono_mempool_alloc (D.44869, 80);
    inst->data.op[1].const_val = 0;
    D.44988 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44988;
    inst->prev = 0B;
    D.44989 = inst->prev;
    inst->next = D.44989;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44990 = inst->sreg3;
    inst->sreg2 = D.44990;
    D.44991 = inst->sreg2;
    inst->sreg1 = D.44991;
    D.44874 = cfg->ip;
    inst->cil_code = D.44874;
    inst->dreg = add_reg;
    inst->sreg1 = mult2_reg;
    D.44892 = arr->dreg;
    inst->sreg2 = D.44892;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    if (D.44876 != 0B) goto <D.44992>; else goto <D.44993>;
    <D.44992>:
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    D.44876->next = inst;
    D.44875 = cfg->cbb;
    D.44876 = D.44875->last_ins;
    inst->prev = D.44876;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    goto <D.44994>;
    <D.44993>:
    D.44875 = cfg->cbb;
    D.44875 = cfg->cbb;
    D.44875->last_ins = inst;
    D.44876 = D.44875->last_ins;
    D.44875->code = D.44876;
    <D.44994>:
  }
  D.44869 = cfg->mempool;
  ins = mono_mempool_alloc (D.44869, 80);
  ins->data.op[1].const_val = 0;
  D.44995 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.44995;
  ins->prev = 0B;
  D.44996 = ins->prev;
  ins->next = D.44996;
  ins->opcode = 538;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.44997 = ins->sreg3;
  ins->sreg2 = D.44997;
  D.44998 = ins->sreg2;
  ins->sreg1 = D.44998;
  D.44874 = cfg->ip;
  ins->cil_code = D.44874;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 32;
  ins->type = 5;
  ins->klass = klass;
  D.44875 = cfg->cbb;
  D.44876 = D.44875->last_ins;
  if (D.44876 != 0B) goto <D.44999>; else goto <D.45000>;
  <D.44999>:
  D.44875 = cfg->cbb;
  D.44876 = D.44875->last_ins;
  D.44876->next = ins;
  D.44875 = cfg->cbb;
  D.44876 = D.44875->last_ins;
  ins->prev = D.44876;
  D.44875 = cfg->cbb;
  D.44875->last_ins = ins;
  goto <D.45001>;
  <D.45000>:
  D.44875 = cfg->cbb;
  D.44875 = cfg->cbb;
  D.44875->last_ins = ins;
  D.44876 = D.44875->last_ins;
  D.44875->code = D.44876;
  <D.45001>:
  D.45002 = ins;
  return D.45002;
}


mini_redirect_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoMethodSignature * signature, struct MonoInst * * args, struct MonoInst * this)
{
  struct MonoClass * D.45004;
  struct MonoClass * D.45005;
  int D.27328;
  int iftmp.405;
  int D.27327;
  const char[20] * D.45011;
  unsigned char D.45012;
  int D.45013;
  unsigned char D.45014;
  int D.45015;
  const unsigned char * D.45020;
  unsigned char D.45021;
  int D.45022;
  const unsigned char * D.45023;
  unsigned char D.45024;
  int D.45025;
  const unsigned char * D.45030;
  unsigned char D.45031;
  int D.45032;
  const unsigned char * D.45033;
  unsigned char D.45034;
  int D.45035;
  const unsigned char * D.45040;
  unsigned char D.45041;
  int D.45042;
  const unsigned char * D.45043;
  unsigned char D.45044;
  int D.45045;
  const char * D.45047;
  <unnamed type> mono_profiler_events.406;
  unsigned int D.45051;
  unsigned int D.45054;
  unsigned int D.45055;
  struct MonoDomain * D.45058;
  _Bool D.45059;
  long int D.45060;
  long int D.45061;
  struct MonoInst * D.45066;
  struct MonoMemPool * D.45067;
  void * D.45068;
  struct MonoInst * D.45069;
  long int D.45070;
  struct MonoInst * D.45071;
  guint16 iftmp.407;
  long unsigned int D.45073;
  long unsigned int D.45074;
  int D.45078;
  int D.45079;
  const unsigned char * D.45080;
  long int D.45083;
  struct MonoInst * D.45084;
  int D.45085;
  int D.45086;
  struct MonoInst * iftmp.408;
  int D.45091;
  void * iftmp.409;
  unsigned int D.45097;
  int D.45098;
  struct MonoBasicBlock * D.45099;
  struct MonoInst * D.45100;
  struct MonoInst * D.45104;

  D.45004 = method->klass;
  D.45005 = mono_defaults.string_class;
  if (D.45004 == D.45005) goto <D.45006>; else goto <D.45007>;
  <D.45006>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 19;
    if (__s2_len <= 3) goto <D.45009>; else goto <D.45010>;
    <D.45009>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.45011 = "InternalAllocateStr";
      D.45012 = MEM[(const unsigned char *)D.45011];
      D.45013 = (int) D.45012;
      D.45014 = *__s2;
      D.45015 = (int) D.45014;
      __result = D.45013 - D.45015;
      {
        if (__s2_len != 0) goto <D.45016>; else goto <D.45017>;
        <D.45016>:
        if (__result == 0) goto <D.45018>; else goto <D.45019>;
        <D.45018>:
        D.45020 = &MEM[(void *)"InternalAllocateStr" + 1B];
        D.45021 = *D.45020;
        D.45022 = (int) D.45021;
        D.45023 = __s2 + 1;
        D.45024 = *D.45023;
        D.45025 = (int) D.45024;
        __result = D.45022 - D.45025;
        if (__s2_len > 1) goto <D.45026>; else goto <D.45027>;
        <D.45026>:
        if (__result == 0) goto <D.45028>; else goto <D.45029>;
        <D.45028>:
        D.45030 = &MEM[(void *)"InternalAllocateStr" + 2B];
        D.45031 = *D.45030;
        D.45032 = (int) D.45031;
        D.45033 = __s2 + 2;
        D.45034 = *D.45033;
        D.45035 = (int) D.45034;
        __result = D.45032 - D.45035;
        if (__s2_len > 2) goto <D.45036>; else goto <D.45037>;
        <D.45036>:
        if (__result == 0) goto <D.45038>; else goto <D.45039>;
        <D.45038>:
        D.45040 = &MEM[(void *)"InternalAllocateStr" + 3B];
        D.45041 = *D.45040;
        D.45042 = (int) D.45041;
        D.45043 = __s2 + 3;
        D.45044 = *D.45043;
        D.45045 = (int) D.45044;
        __result = D.45042 - D.45045;
        <D.45039>:
        <D.45037>:
        <D.45029>:
        <D.45027>:
        <D.45019>:
        <D.45017>:
      }
      D.27327 = __result;
    }
    iftmp.405 = -D.27327;
    goto <D.45046>;
    <D.45010>:
    D.45047 = method->name;
    iftmp.405 = __builtin_strcmp (D.45047, "InternalAllocateStr");
    <D.45046>:
    D.27328 = iftmp.405;
  }
  if (D.27328 == 0) goto <D.45048>; else goto <D.45049>;
  <D.45048>:
  mono_profiler_events.406 = mono_profiler_events;
  D.45051 = mono_profiler_events.406 & 128;
  if (D.45051 == 0) goto <D.45052>; else goto <D.45053>;
  <D.45052>:
  D.45054 = cfg->opt;
  D.45055 = D.45054 & 512;
  if (D.45055 == 0) goto <D.45056>; else goto <D.45057>;
  <D.45056>:
  {
    struct MonoInst * iargs[2];
    struct MonoVTable * vtable;
    struct MonoMethod * managed_alloc;

    try
      {
        D.45058 = cfg->domain;
        D.45004 = method->klass;
        vtable = mono_class_vtable (D.45058, D.45004);
        managed_alloc = 0B;
        D.45059 = vtable == 0B;
        D.45060 = (long int) D.45059;
        D.45061 = __builtin_expect (D.45060, 0);
        if (D.45061 != 0) goto <D.45062>; else goto <D.45063>;
        <D.45062>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 5598, "vtable");
        <D.45063>:
        D.45004 = method->klass;
        managed_alloc = mono_gc_get_managed_allocator (D.45004, 0);
        if (managed_alloc == 0B) goto <D.45064>; else goto <D.45065>;
        <D.45064>:
        D.45066 = 0B;
        return D.45066;
        <D.45065>:
        D.45067 = cfg->mempool;
        D.45068 = mono_mempool_alloc (D.45067, 80);
        iargs[0] = D.45068;
        D.45069 = iargs[0];
        D.45069 = iargs[0];
        D.45069->data.op[1].const_val = 0;
        D.45070 = D.45069->data.op[1].const_val;
        D.45069->data.op[0].const_val = D.45070;
        D.45069 = iargs[0];
        D.45069 = iargs[0];
        D.45069->prev = 0B;
        D.45071 = D.45069->prev;
        D.45069->next = D.45071;
        D.45069 = iargs[0];
        D.45073 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45074 = D.45073 & 274877906944;
        if (D.45074 != 0) goto <D.45075>; else goto <D.45076>;
        <D.45075>:
        iftmp.407 = 734;
        goto <D.45077>;
        <D.45076>:
        iftmp.407 = 363;
        <D.45077>:
        D.45069->opcode = iftmp.407;
        D.45069 = iargs[0];
        D.45069->flags = 0;
        D.45069 = iargs[0];
        D.45069->type = 0;
        D.45069 = iargs[0];
        D.45069->dreg = -1;
        D.45069 = iargs[0];
        D.45069 = iargs[0];
        D.45069 = iargs[0];
        D.45069->sreg3 = -1;
        D.45078 = D.45069->sreg3;
        D.45069->sreg2 = D.45078;
        D.45079 = D.45069->sreg2;
        D.45069->sreg1 = D.45079;
        D.45069 = iargs[0];
        D.45080 = cfg->ip;
        D.45069->cil_code = D.45080;
        D.45073 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45074 = D.45073 & 274877906944;
        if (D.45074 != 0) goto <D.45081>; else goto <D.45082>;
        <D.45081>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.45067 = cfg->mempool;
          group = mono_mempool_alloc (D.45067, 80);
          group->data.op[1].const_val = 0;
          D.45083 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.45083;
          group->prev = 0B;
          D.45084 = group->prev;
          group->next = D.45084;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.45085 = group->sreg3;
          group->sreg2 = D.45085;
          D.45086 = group->sreg2;
          group->sreg1 = D.45086;
          D.45080 = cfg->ip;
          group->cil_code = D.45080;
          D.45073 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.45074 = D.45073 & 274877906944;
          if (D.45074 != 0) goto <D.45088>; else goto <D.45089>;
          <D.45088>:
          iftmp.408 = vtable->klass;
          goto <D.45090>;
          <D.45089>:
          iftmp.408 = vtable;
          <D.45090>:
          group->data.op[0].src = iftmp.408;
          group->data.op[1].src = 14B;
          D.45069 = iargs[0];
          D.45091 = got_loc->dreg;
          D.45069->sreg1 = D.45091;
          D.45069 = iargs[0];
          D.45069->data.op[1].p = group;
        }
        goto <D.45092>;
        <D.45082>:
        D.45069 = iargs[0];
        D.45073 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45074 = D.45073 & 274877906944;
        if (D.45074 != 0) goto <D.45094>; else goto <D.45095>;
        <D.45094>:
        iftmp.409 = vtable->klass;
        goto <D.45096>;
        <D.45095>:
        iftmp.409 = vtable;
        <D.45096>:
        D.45069->data.op[0].p = iftmp.409;
        D.45069 = iargs[0];
        D.45069->data.op[1].src = 14B;
        <D.45092>:
        D.45069 = iargs[0];
        D.45069->type = 3;
        D.45069 = iargs[0];
        D.45097 = alloc_dreg (cfg, 3);
        D.45098 = (int) D.45097;
        D.45069->dreg = D.45098;
        D.45099 = cfg->cbb;
        D.45100 = D.45099->last_ins;
        if (D.45100 != 0B) goto <D.45101>; else goto <D.45102>;
        <D.45101>:
        D.45099 = cfg->cbb;
        D.45100 = D.45099->last_ins;
        D.45069 = iargs[0];
        D.45100->next = D.45069;
        D.45069 = iargs[0];
        D.45099 = cfg->cbb;
        D.45100 = D.45099->last_ins;
        D.45069->prev = D.45100;
        D.45099 = cfg->cbb;
        D.45069 = iargs[0];
        D.45099->last_ins = D.45069;
        goto <D.45103>;
        <D.45102>:
        D.45099 = cfg->cbb;
        D.45099 = cfg->cbb;
        D.45069 = iargs[0];
        D.45099->last_ins = D.45069;
        D.45100 = D.45099->last_ins;
        D.45099->code = D.45100;
        <D.45103>:
        D.45104 = *args;
        iargs[1] = D.45104;
        D.45066 = mono_emit_method_call (cfg, managed_alloc, &iargs, this);
        return D.45066;
      }
    finally
      {
        iargs = {CLOBBER};
      }
  }
  <D.45057>:
  <D.45053>:
  <D.45049>:
  <D.45007>:
  D.45066 = 0B;
  return D.45066;
}


is_supported_tail_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, int call_opcode)
{
  struct MonoMethodSignature * D.45107;
  struct MonoMethodSignature * D.45108;
  struct MonoType * D.45111;
  long unsigned int D.45112;
  long unsigned int D.45113;
  unsigned char D.45115;
  short unsigned int D.45117;
  int D.45118;
  long unsigned int D.45119;
  long unsigned int D.45120;
  struct MonoClass * D.45123;
  long unsigned int D.45124;
  long unsigned int D.45125;
  short unsigned int D.45128;
  int D.45129;
  int D.45130;
  struct MonoMethod * D.45133;
  long unsigned int D.45134;
  long unsigned int D.45135;
  long unsigned int D.45138;
  long unsigned int D.45139;
  gboolean D.45146;
  gboolean supported_tail_call;
  int i;

  D.45107 = mono_method_signature (method);
  D.45108 = mono_method_signature (cmethod);
  supported_tail_call = mono_arch_tail_call_supported (cfg, D.45107, D.45108);
  i = 0;
  goto <D.27676>;
  <D.27675>:
  D.45111 = fsig->params[i];
  D.45112 = BIT_FIELD_REF <*D.45111, 64, 64>;
  D.45113 = D.45112 & 1073741824;
  if (D.45113 != 0) goto <D.45109>; else goto <D.45114>;
  <D.45114>:
  D.45111 = fsig->params[i];
  D.45115 = D.45111->type;
  if (D.45115 == 15) goto <D.45109>; else goto <D.45116>;
  <D.45116>:
  D.45111 = fsig->params[i];
  D.45115 = D.45111->type;
  if (D.45115 == 27) goto <D.45109>; else goto <D.45110>;
  <D.45109>:
  supported_tail_call = 0;
  <D.45110>:
  i = i + 1;
  <D.27676>:
  D.45117 = fsig->param_count;
  D.45118 = (int) D.45117;
  if (D.45118 > i) goto <D.27675>; else goto <D.27677>;
  <D.27677>:
  D.45119 = BIT_FIELD_REF <*fsig, 64, 64>;
  D.45120 = D.45119 & 18014398509481984;
  if (D.45120 != 0) goto <D.45121>; else goto <D.45122>;
  <D.45121>:
  D.45123 = cmethod->klass;
  D.45124 = BIT_FIELD_REF <*D.45123, 64, 256>;
  D.45125 = D.45124 & 8;
  if (D.45125 != 0) goto <D.45126>; else goto <D.45127>;
  <D.45126>:
  supported_tail_call = 0;
  <D.45127>:
  <D.45122>:
  D.45128 = cmethod->flags;
  D.45129 = (int) D.45128;
  D.45130 = D.45129 & 8192;
  if (D.45130 != 0) goto <D.45131>; else goto <D.45132>;
  <D.45131>:
  supported_tail_call = 0;
  <D.45132>:
  D.45133 = cfg->method;
  D.45134 = BIT_FIELD_REF <*D.45133, 64, 256>;
  D.45135 = D.45134 & 256;
  if (D.45135 != 0) goto <D.45136>; else goto <D.45137>;
  <D.45136>:
  supported_tail_call = 0;
  <D.45137>:
  D.45138 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.45139 = D.45138 & 124;
  if (D.45139 != 0) goto <D.45140>; else goto <D.45141>;
  <D.45140>:
  D.45138 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.45139 = D.45138 & 124;
  if (D.45139 != 68) goto <D.45142>; else goto <D.45143>;
  <D.45142>:
  supported_tail_call = 0;
  <D.45143>:
  <D.45141>:
  if (call_opcode != 40) goto <D.45144>; else goto <D.45145>;
  <D.45144>:
  supported_tail_call = 0;
  <D.45145>:
  D.45146 = supported_tail_call;
  return D.45146;
}


mono_emit_widen_call_res (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoMethodSignature * fsig)
{
  struct MonoType * D.45148;
  int D.45149;
  long unsigned int D.45152;
  long unsigned int D.45153;
  long unsigned int D.45156;
  long unsigned int D.45157;
  unsigned int D.45160;
  unsigned int D.45163;
  struct MonoMemPool * D.45164;
  long int D.45165;
  struct MonoInst * D.45166;
  short unsigned int D.45167;
  int D.45168;
  int D.45169;
  const unsigned char * D.45170;
  int D.45171;
  struct MonoBasicBlock * D.45172;
  struct MonoInst * D.45173;
  unsigned char D.45177;
  struct MonoInst * D.45178;

  D.45148 = fsig->ret;
  D.45149 = mono_type_is_void (D.45148);
  if (D.45149 == 0) goto <D.45150>; else goto <D.45151>;
  <D.45150>:
  D.45152 = BIT_FIELD_REF <*fsig, 64, 64>;
  D.45153 = D.45152 & 72057594037927936;
  if (D.45153 != 0) goto <D.45154>; else goto <D.45155>;
  <D.45154>:
  D.45148 = fsig->ret;
  D.45156 = BIT_FIELD_REF <*D.45148, 64, 64>;
  D.45157 = D.45156 & 1073741824;
  if (D.45157 == 0) goto <D.45158>; else goto <D.45159>;
  <D.45158>:
  {
    int widen_op;

    widen_op = -1;
    D.45148 = fsig->ret;
    D.45160 = mono_type_to_load_membase (cfg, D.45148);
    switch (D.45160) <default: <D.25944>, case 389: <D.25939>, case 390: <D.25941>, case 391: <D.25942>, case 392: <D.25943>>
    <D.25939>:
    widen_op = 580;
    goto <D.25940>;
    <D.25941>:
    widen_op = 591;
    goto <D.25940>;
    <D.25942>:
    widen_op = 581;
    goto <D.25940>;
    <D.25943>:
    widen_op = 590;
    goto <D.25940>;
    <D.25944>:
    goto <D.25940>;
    <D.25940>:
    if (widen_op != -1) goto <D.45161>; else goto <D.45162>;
    <D.45161>:
    {
      int dreg;
      struct MonoInst * widen;

      D.45163 = alloc_preg (cfg);
      dreg = (int) D.45163;
      D.45164 = cfg->mempool;
      widen = mono_mempool_alloc (D.45164, 80);
      widen->data.op[1].const_val = 0;
      D.45165 = widen->data.op[1].const_val;
      widen->data.op[0].const_val = D.45165;
      widen->prev = 0B;
      D.45166 = widen->prev;
      widen->next = D.45166;
      D.45167 = (short unsigned int) widen_op;
      widen->opcode = D.45167;
      widen->flags = 0;
      widen->type = 0;
      widen->dreg = -1;
      widen->sreg3 = -1;
      D.45168 = widen->sreg3;
      widen->sreg2 = D.45168;
      D.45169 = widen->sreg2;
      widen->sreg1 = D.45169;
      D.45170 = cfg->ip;
      widen->cil_code = D.45170;
      widen->dreg = dreg;
      D.45171 = ins->dreg;
      widen->sreg1 = D.45171;
      D.45172 = cfg->cbb;
      D.45173 = D.45172->last_ins;
      if (D.45173 != 0B) goto <D.45174>; else goto <D.45175>;
      <D.45174>:
      D.45172 = cfg->cbb;
      D.45173 = D.45172->last_ins;
      D.45173->next = widen;
      D.45172 = cfg->cbb;
      D.45173 = D.45172->last_ins;
      widen->prev = D.45173;
      D.45172 = cfg->cbb;
      D.45172->last_ins = widen;
      goto <D.45176>;
      <D.45175>:
      D.45172 = cfg->cbb;
      D.45172 = cfg->cbb;
      D.45172->last_ins = widen;
      D.45173 = D.45172->last_ins;
      D.45172->code = D.45173;
      <D.45176>:
      D.45177 = ins->type;
      widen->type = D.45177;
      ins = widen;
    }
    <D.45162>:
  }
  <D.45159>:
  <D.45155>:
  <D.45151>:
  D.45178 = ins;
  return D.45178;
}


emit_pop_lmf (struct MonoCompile * cfg)
{
  long unsigned int D.45181;
  long unsigned int D.45182;
  struct MonoMemPool * D.45185;
  long int D.45186;
  struct MonoInst * D.45187;
  int D.45188;
  int D.45189;
  const unsigned char * D.45190;
  struct MonoInst * D.45191;
  unsigned char D.45192;
  unsigned char D.45193;
  struct MonoClass * D.45194;
  unsigned int D.45195;
  int D.45196;
  int D.45197;
  _Bool D.45198;
  long int D.45199;
  long int D.45200;
  struct MonoType * D.45203;
  int D.45204;
  struct MonoInst * iftmp.410;
  int D.45210;
  int D.45211;
  unsigned int D.45212;
  unsigned int D.45213;
  struct MonoInst * * D.45216;
  sizetype D.45217;
  sizetype D.45218;
  sizetype D.45219;
  struct MonoInst * * D.45220;
  struct MonoInst * iftmp.411;
  int D.45223;
  unsigned int D.45224;
  sizetype D.45227;
  sizetype D.45228;
  struct MonoInst * * D.45229;
  _Bool D.45231;
  long int D.45232;
  long int D.45233;
  _Bool D.45236;
  long int D.45237;
  long int D.45238;
  unsigned char D.45241;
  unsigned char D.45242;
  unsigned char D.45243;
  unsigned char D.45244;
  struct MonoBasicBlock * D.45245;
  struct MonoInst * D.45246;
  long unsigned int D.45252;
  int D.45254;
  unsigned int D.45256;
  struct MonoInst * D.45260;
  struct MonoClass * D.45263;
  struct MonoType * D.45264;
  struct MonoInst * D.45265;
  unsigned int D.45266;
  int lmf_reg;
  int lmf_addr_reg;
  int prev_lmf_reg;
  struct MonoInst * ins;

  D.45181 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45182 = D.45181 & 288230376151711744;
  if (D.45182 == 0) goto <D.45183>; else goto <D.45184>;
  <D.45183>:
  return;
  <D.45184>:
  D.45185 = cfg->mempool;
  ins = mono_mempool_alloc (D.45185, 80);
  ins->data.op[1].const_val = 0;
  D.45186 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45186;
  ins->prev = 0B;
  D.45187 = ins->prev;
  ins->next = D.45187;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45188 = ins->sreg3;
  ins->sreg2 = D.45188;
  D.45189 = ins->sreg2;
  ins->sreg1 = D.45189;
  D.45190 = cfg->ip;
  ins->cil_code = D.45190;
  D.45191 = cfg->lmf_var;
  ins->data.op[0].p = D.45191;
  D.45191 = cfg->lmf_var;
  D.45191 = cfg->lmf_var;
  D.45192 = D.45191->flags;
  D.45193 = D.45192 | 16;
  D.45191->flags = D.45193;
  ins->type = 5;
  D.45191 = cfg->lmf_var;
  D.45194 = D.45191->klass;
  ins->klass = D.45194;
  D.45195 = alloc_dreg (cfg, 5);
  D.45196 = (int) D.45195;
  ins->dreg = D.45196;
  cfg->has_indirection = 1;
  D.45197 = cfg->gsharedvt;
  D.45198 = D.45197 != 0;
  D.45199 = (long int) D.45198;
  D.45200 = __builtin_expect (D.45199, 0);
  if (D.45200 != 0) goto <D.45201>; else goto <D.45202>;
  <D.45201>:
  D.45191 = cfg->lmf_var;
  D.45203 = D.45191->data.op[1].vtype;
  D.45204 = mini_is_gsharedvt_variable_type (cfg, D.45203);
  if (D.45204 != 0) goto <D.45205>; else goto <D.45206>;
  <D.45205>:
  handle_gsharedvt_ldaddr (cfg);
  <D.45206>:
  <D.45202>:
  if (0 != 0) goto <D.45207>; else goto <D.45208>;
  <D.45207>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.45191 = cfg->lmf_var;
    D.45210 = D.45191->dreg;
    D.45211 = D.45210 + 1;
    D.45212 = (unsigned int) D.45211;
    D.45213 = cfg->vreg_to_inst_len;
    if (D.45212 < D.45213) goto <D.45214>; else goto <D.45215>;
    <D.45214>:
    D.45216 = cfg->vreg_to_inst;
    D.45191 = cfg->lmf_var;
    D.45210 = D.45191->dreg;
    D.45217 = (sizetype) D.45210;
    D.45218 = D.45217 + 1;
    D.45219 = D.45218 * 8;
    D.45220 = D.45216 + D.45219;
    iftmp.410 = *D.45220;
    goto <D.45221>;
    <D.45215>:
    iftmp.410 = 0B;
    <D.45221>:
    var1 = iftmp.410;
    D.45191 = cfg->lmf_var;
    D.45210 = D.45191->dreg;
    D.45223 = D.45210 + 2;
    D.45224 = (unsigned int) D.45223;
    D.45213 = cfg->vreg_to_inst_len;
    if (D.45224 < D.45213) goto <D.45225>; else goto <D.45226>;
    <D.45225>:
    D.45216 = cfg->vreg_to_inst;
    D.45191 = cfg->lmf_var;
    D.45210 = D.45191->dreg;
    D.45217 = (sizetype) D.45210;
    D.45227 = D.45217 + 2;
    D.45228 = D.45227 * 8;
    D.45229 = D.45216 + D.45228;
    iftmp.411 = *D.45229;
    goto <D.45230>;
    <D.45226>:
    iftmp.411 = 0B;
    <D.45230>:
    var2 = iftmp.411;
    D.45231 = var1 == 0B;
    D.45232 = (long int) D.45231;
    D.45233 = __builtin_expect (D.45232, 0);
    if (D.45233 != 0) goto <D.45234>; else goto <D.45235>;
    <D.45234>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1970, "var1");
    <D.45235>:
    D.45236 = var2 == 0B;
    D.45237 = (long int) D.45236;
    D.45238 = __builtin_expect (D.45237, 0);
    if (D.45238 != 0) goto <D.45239>; else goto <D.45240>;
    <D.45239>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1970, "var2");
    <D.45240>:
    D.45241 = var1->flags;
    D.45242 = D.45241 | 16;
    var1->flags = D.45242;
    D.45243 = var2->flags;
    D.45244 = D.45243 | 16;
    var2->flags = D.45244;
  }
  <D.45208>:
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  if (D.45246 != 0B) goto <D.45247>; else goto <D.45248>;
  <D.45247>:
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  D.45246->next = ins;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  ins->prev = D.45246;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  goto <D.45249>;
  <D.45248>:
  D.45245 = cfg->cbb;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  D.45246 = D.45245->last_ins;
  D.45245->code = D.45246;
  <D.45249>:
  lmf_reg = ins->dreg;
  D.45181 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45252 = D.45181 & 576460752303423488;
  if (D.45252 != 0) goto <D.45253>; else goto <D.45250>;
  <D.45253>:
  D.45254 = mini_tls_get_supported (cfg, 3);
  if (D.45254 != 0) goto <D.45255>; else goto <D.45250>;
  <D.45255>:
  D.45256 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.45256;
  D.45185 = cfg->mempool;
  ins = mono_mempool_alloc (D.45185, 80);
  ins->data.op[1].const_val = 0;
  D.45186 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45186;
  ins->prev = 0B;
  D.45187 = ins->prev;
  ins->next = D.45187;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45188 = ins->sreg3;
  ins->sreg2 = D.45188;
  D.45189 = ins->sreg2;
  ins->sreg1 = D.45189;
  D.45190 = cfg->ip;
  ins->cil_code = D.45190;
  ins->dreg = prev_lmf_reg;
  ins->sreg1 = lmf_reg;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  if (D.45246 != 0B) goto <D.45257>; else goto <D.45258>;
  <D.45257>:
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  D.45246->next = ins;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  ins->prev = D.45246;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  goto <D.45259>;
  <D.45258>:
  D.45245 = cfg->cbb;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  D.45246 = D.45245->last_ins;
  D.45245->code = D.45246;
  <D.45259>:
  emit_tls_set (cfg, prev_lmf_reg, 3);
  goto <D.45251>;
  <D.45250>:
  D.45260 = cfg->lmf_addr_var;
  if (D.45260 == 0B) goto <D.45261>; else goto <D.45262>;
  <D.45261>:
  D.45263 = mono_defaults.int_class;
  D.45264 = &D.45263->byval_arg;
  D.45265 = mono_compile_create_var (cfg, D.45264, 329);
  cfg->lmf_addr_var = D.45265;
  <D.45262>:
  D.45260 = cfg->lmf_addr_var;
  lmf_addr_reg = D.45260->dreg;
  D.45266 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.45266;
  D.45185 = cfg->mempool;
  ins = mono_mempool_alloc (D.45185, 80);
  ins->data.op[1].const_val = 0;
  D.45186 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45186;
  ins->prev = 0B;
  D.45187 = ins->prev;
  ins->next = D.45187;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45188 = ins->sreg3;
  ins->sreg2 = D.45188;
  D.45189 = ins->sreg2;
  ins->sreg1 = D.45189;
  D.45190 = cfg->ip;
  ins->cil_code = D.45190;
  ins->dreg = prev_lmf_reg;
  ins->sreg1 = lmf_reg;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  if (D.45246 != 0B) goto <D.45267>; else goto <D.45268>;
  <D.45267>:
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  D.45246->next = ins;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  ins->prev = D.45246;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  goto <D.45269>;
  <D.45268>:
  D.45245 = cfg->cbb;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  D.45246 = D.45245->last_ins;
  D.45245->code = D.45246;
  <D.45269>:
  D.45185 = cfg->mempool;
  ins = mono_mempool_alloc (D.45185, 80);
  ins->data.op[1].const_val = 0;
  D.45186 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45186;
  ins->prev = 0B;
  D.45187 = ins->prev;
  ins->next = D.45187;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45188 = ins->sreg3;
  ins->sreg2 = D.45188;
  D.45189 = ins->sreg2;
  ins->sreg1 = D.45189;
  D.45190 = cfg->ip;
  ins->cil_code = D.45190;
  ins->sreg1 = prev_lmf_reg;
  ins->dreg = lmf_addr_reg;
  ins->data.op[0].const_val = 0;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  if (D.45246 != 0B) goto <D.45270>; else goto <D.45271>;
  <D.45270>:
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  D.45246->next = ins;
  D.45245 = cfg->cbb;
  D.45246 = D.45245->last_ins;
  ins->prev = D.45246;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  goto <D.45272>;
  <D.45271>:
  D.45245 = cfg->cbb;
  D.45245 = cfg->cbb;
  D.45245->last_ins = ins;
  D.45246 = D.45245->last_ins;
  D.45245->code = D.45246;
  <D.45272>:
  <D.45251>:
}


emit_tls_set (struct MonoCompile * cfg, int sreg1, int tls_key)
{
  long unsigned int D.45274;
  long unsigned int D.45275;
  struct MonoMemPool * D.45280;
  long int D.45281;
  struct MonoInst * D.45282;
  guint16 iftmp.412;
  int D.45287;
  int D.45288;
  const unsigned char * D.45289;
  long int D.45292;
  struct MonoInst * D.45293;
  int D.45294;
  int D.45295;
  long int D.45296;
  struct MonoInst * D.45297;
  int D.45298;
  void * D.45300;
  unsigned int D.45301;
  int D.45302;
  <unnamed type> tls_key.413;
  long int D.45305;
  void * D.45306;
  unsigned int D.45307;
  int D.45308;
  struct MonoBasicBlock * D.45309;
  struct MonoInst * D.45310;
  long int D.45314;
  struct MonoInst * D.45315;
  int D.45316;
  int D.45317;
  int D.45318;
  int D.45323;
  long int D.45324;
  struct MonoInst * ins;
  struct MonoInst * c;

  D.45274 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45275 = D.45274 & 274877906944;
  if (D.45275 != 0) goto <D.45276>; else goto <D.45277>;
  <D.45276>:
  D.45274 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45275 = D.45274 & 274877906944;
  if (D.45275 != 0) goto <D.45278>; else goto <D.45279>;
  <D.45278>:
  D.45280 = cfg->mempool;
  c = mono_mempool_alloc (D.45280, 80);
  c->data.op[1].const_val = 0;
  D.45281 = c->data.op[1].const_val;
  c->data.op[0].const_val = D.45281;
  c->prev = 0B;
  D.45282 = c->prev;
  c->next = D.45282;
  D.45274 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45275 = D.45274 & 274877906944;
  if (D.45275 != 0) goto <D.45284>; else goto <D.45285>;
  <D.45284>:
  iftmp.412 = 734;
  goto <D.45286>;
  <D.45285>:
  iftmp.412 = 363;
  <D.45286>:
  c->opcode = iftmp.412;
  c->flags = 0;
  c->type = 0;
  c->dreg = -1;
  c->sreg3 = -1;
  D.45287 = c->sreg3;
  c->sreg2 = D.45287;
  D.45288 = c->sreg2;
  c->sreg1 = D.45288;
  D.45289 = cfg->ip;
  c->cil_code = D.45289;
  D.45274 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45275 = D.45274 & 274877906944;
  if (D.45275 != 0) goto <D.45290>; else goto <D.45291>;
  <D.45290>:
  {
    struct MonoInst * group;
    struct MonoInst * got_loc;

    got_loc = mono_get_got_var (cfg);
    D.45280 = cfg->mempool;
    group = mono_mempool_alloc (D.45280, 80);
    group->data.op[1].const_val = 0;
    D.45292 = group->data.op[1].const_val;
    group->data.op[0].const_val = D.45292;
    group->prev = 0B;
    D.45293 = group->prev;
    group->next = D.45293;
    group->opcode = 733;
    group->flags = 0;
    group->type = 0;
    group->dreg = -1;
    group->sreg3 = -1;
    D.45294 = group->sreg3;
    group->sreg2 = D.45294;
    D.45295 = group->sreg2;
    group->sreg1 = D.45295;
    D.45289 = cfg->ip;
    group->cil_code = D.45289;
    D.45296 = (long int) tls_key;
    D.45297 = (struct MonoInst *) D.45296;
    group->data.op[0].src = D.45297;
    group->data.op[1].src = 48B;
    D.45298 = got_loc->dreg;
    c->sreg1 = D.45298;
    c->data.op[1].p = group;
  }
  goto <D.45299>;
  <D.45291>:
  D.45296 = (long int) tls_key;
  D.45300 = (void *) D.45296;
  c->data.op[0].p = D.45300;
  c->data.op[1].src = 48B;
  <D.45299>:
  c->type = 3;
  D.45301 = alloc_dreg (cfg, 3);
  D.45302 = (int) D.45301;
  c->dreg = D.45302;
  goto <D.45303>;
  <D.45279>:
  {
    int _offset;

    tls_key.413 = (<unnamed type>) tls_key;
    _offset = mini_get_tls_offset (tls_key.413);
    D.45280 = cfg->mempool;
    c = mono_mempool_alloc (D.45280, 80);
    c->data.op[1].const_val = 0;
    D.45281 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.45281;
    c->prev = 0B;
    D.45282 = c->prev;
    c->next = D.45282;
    c->opcode = 363;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.45287 = c->sreg3;
    c->sreg2 = D.45287;
    D.45288 = c->sreg2;
    c->sreg1 = D.45288;
    D.45289 = cfg->ip;
    c->cil_code = D.45289;
    D.45305 = (long int) _offset;
    D.45306 = (void *) D.45305;
    c->data.op[0].p = D.45306;
    c->type = 3;
    D.45307 = alloc_dreg (cfg, 3);
    D.45308 = (int) D.45307;
    c->dreg = D.45308;
  }
  <D.45303>:
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  if (D.45310 != 0B) goto <D.45311>; else goto <D.45312>;
  <D.45311>:
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  D.45310->next = c;
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  c->prev = D.45310;
  D.45309 = cfg->cbb;
  D.45309->last_ins = c;
  goto <D.45313>;
  <D.45312>:
  D.45309 = cfg->cbb;
  D.45309 = cfg->cbb;
  D.45309->last_ins = c;
  D.45310 = D.45309->last_ins;
  D.45309->code = D.45310;
  <D.45313>:
  D.45280 = cfg->mempool;
  ins = mono_mempool_alloc (D.45280, 80);
  ins->data.op[1].const_val = 0;
  D.45314 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45314;
  ins->prev = 0B;
  D.45315 = ins->prev;
  ins->next = D.45315;
  ins->opcode = 794;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45316 = ins->sreg3;
  ins->sreg2 = D.45316;
  D.45317 = ins->sreg2;
  ins->sreg1 = D.45317;
  D.45289 = cfg->ip;
  ins->cil_code = D.45289;
  ins->sreg1 = sreg1;
  D.45318 = c->dreg;
  ins->sreg2 = D.45318;
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  if (D.45310 != 0B) goto <D.45319>; else goto <D.45320>;
  <D.45319>:
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  D.45310->next = ins;
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  ins->prev = D.45310;
  D.45309 = cfg->cbb;
  D.45309->last_ins = ins;
  goto <D.45321>;
  <D.45320>:
  D.45309 = cfg->cbb;
  D.45309 = cfg->cbb;
  D.45309->last_ins = ins;
  D.45310 = D.45309->last_ins;
  D.45309->code = D.45310;
  <D.45321>:
  goto <D.45322>;
  <D.45277>:
  D.45280 = cfg->mempool;
  ins = mono_mempool_alloc (D.45280, 80);
  ins->data.op[1].const_val = 0;
  D.45314 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45314;
  ins->prev = 0B;
  D.45315 = ins->prev;
  ins->next = D.45315;
  ins->opcode = 793;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45316 = ins->sreg3;
  ins->sreg2 = D.45316;
  D.45317 = ins->sreg2;
  ins->sreg1 = D.45317;
  D.45289 = cfg->ip;
  ins->cil_code = D.45289;
  ins->sreg1 = sreg1;
  tls_key.413 = (<unnamed type>) tls_key;
  D.45323 = mini_get_tls_offset (tls_key.413);
  D.45324 = (long int) D.45323;
  ins->data.op[0].const_val = D.45324;
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  if (D.45310 != 0B) goto <D.45325>; else goto <D.45326>;
  <D.45325>:
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  D.45310->next = ins;
  D.45309 = cfg->cbb;
  D.45310 = D.45309->last_ins;
  ins->prev = D.45310;
  D.45309 = cfg->cbb;
  D.45309->last_ins = ins;
  goto <D.45327>;
  <D.45326>:
  D.45309 = cfg->cbb;
  D.45309 = cfg->cbb;
  D.45309->last_ins = ins;
  D.45310 = D.45309->last_ins;
  D.45309->code = D.45310;
  <D.45327>:
  <D.45322>:
}


ldind_to_load_membase (int opcode)
{
  int D.45328;

  switch (opcode) <default: <D.28854>, case 70: <D.28843>, case 71: <D.28844>, case 72: <D.28845>, case 73: <D.28846>, case 74: <D.28847>, case 75: <D.28848>, case 76: <D.28851>, case 77: <D.28849>, case 78: <D.28852>, case 79: <D.28853>, case 80: <D.28850>>
  <D.28843>:
  D.45328 = 389;
  return D.45328;
  <D.28844>:
  D.45328 = 390;
  return D.45328;
  <D.28845>:
  D.45328 = 391;
  return D.45328;
  <D.28846>:
  D.45328 = 392;
  return D.45328;
  <D.28847>:
  D.45328 = 393;
  return D.45328;
  <D.28848>:
  D.45328 = 394;
  return D.45328;
  <D.28849>:
  D.45328 = 388;
  return D.45328;
  <D.28850>:
  D.45328 = 388;
  return D.45328;
  <D.28851>:
  D.45328 = 395;
  return D.45328;
  <D.28852>:
  D.45328 = 396;
  return D.45328;
  <D.28853>:
  D.45328 = 397;
  return D.45328;
  <D.28854>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12163);
  D.45328 = -1;
  return D.45328;
}


stind_to_store_membase (int opcode)
{
  int D.45330;

  switch (opcode) <default: <D.28866>, case 81: <D.28862>, case 82: <D.28858>, case 83: <D.28859>, case 84: <D.28860>, case 85: <D.28863>, case 86: <D.28864>, case 87: <D.28865>, case 223: <D.28861>>
  <D.28858>:
  D.45330 = 375;
  return D.45330;
  <D.28859>:
  D.45330 = 376;
  return D.45330;
  <D.28860>:
  D.45330 = 377;
  return D.45330;
  <D.28861>:
  <D.28862>:
  D.45330 = 374;
  return D.45330;
  <D.28863>:
  D.45330 = 378;
  return D.45330;
  <D.28864>:
  D.45330 = 379;
  return D.45330;
  <D.28865>:
  D.45330 = 380;
  return D.45330;
  <D.28866>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12189);
  D.45330 = -1;
  return D.45330;
}


is_exception_class (struct MonoClass * class)
{
  struct MonoClass * D.45332;
  gboolean D.45335;

  goto <D.27648>;
  <D.27647>:
  D.45332 = mono_defaults.exception_class;
  if (D.45332 == class) goto <D.45333>; else goto <D.45334>;
  <D.45333>:
  D.45335 = 1;
  return D.45335;
  <D.45334>:
  class = class->parent;
  <D.27648>:
  if (class != 0B) goto <D.27647>; else goto <D.27649>;
  <D.27649>:
  D.45335 = 0;
  return D.45335;
}


check_call_signature (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * args)
{
  long unsigned int D.45337;
  long unsigned int D.45338;
  struct MonoInst * D.45341;
  unsigned char D.45342;
  unsigned char D.45343;
  int D.45348;
  struct MonoType * D.45349;
  long unsigned int D.45350;
  long unsigned int D.45351;
  long unsigned int D.45354;
  long unsigned int D.45355;
  struct MonoInst * * D.45356;
  struct MonoInst * D.45357;
  unsigned char D.45358;
  struct MonoGenericSharingContext * D.45363;
  unsigned char D.45364;
  int D.45365;
  struct MonoClass * D.45384;
  long unsigned int D.45385;
  long unsigned int D.45386;
  struct MonoGenericClass * D.45393;
  struct MonoClass * D.45394;
  short unsigned int D.45397;
  int D.45398;
  struct MonoType * simple_type;
  int i;
  void handle_enum = <<< error >>>;

  D.45337 = BIT_FIELD_REF <*sig, 64, 64>;
  D.45338 = D.45337 & 18014398509481984;
  if (D.45338 != 0) goto <D.45339>; else goto <D.45340>;
  <D.45339>:
  D.45341 = *args;
  D.45342 = D.45341->type;
  D.45343 = D.45342 + 251;
  if (D.45343 > 1) goto <D.45344>; else goto <D.45345>;
  <D.45344>:
  D.45341 = *args;
  D.45342 = D.45341->type;
  if (D.45342 != 3) goto <D.45346>; else goto <D.45347>;
  <D.45346>:
  D.45348 = 1;
  return D.45348;
  <D.45347>:
  <D.45345>:
  args = args + 8;
  <D.45340>:
  i = 0;
  goto <D.25753>;
  <D.25752>:
  D.45349 = sig->params[i];
  D.45350 = BIT_FIELD_REF <*D.45349, 64, 64>;
  D.45351 = D.45350 & 1073741824;
  if (D.45351 != 0) goto <D.45352>; else goto <D.45353>;
  <D.45352>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 5) goto <D.45359>; else goto <D.45360>;
  <D.45359>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 3) goto <D.45361>; else goto <D.45362>;
  <D.45361>:
  D.45348 = 1;
  return D.45348;
  <D.45362>:
  <D.45360>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.45353>:
  simple_type = sig->params[i];
  D.45363 = cfg->generic_sharing_context;
  simple_type = mini_get_basic_type_from_generic (D.45363, simple_type);
  handle_enum:
  D.45364 = simple_type->type;
  D.45365 = (int) D.45364;
  switch (D.45365) <default: <D.25750>, case 1: <D.25723>, case 2: <D.25726>, case 3: <D.25729>, case 4: <D.25724>, case 5: <D.25725>, case 6: <D.25727>, case 7: <D.25728>, case 8: <D.25730>, case 9: <D.25731>, case 10: <D.25741>, case 11: <D.25742>, case 12: <D.25743>, case 13: <D.25744>, case 14: <D.25737>, case 15: <D.25734>, case 17: <D.25745>, case 18: <D.25736>, case 19: <D.25748>, case 20: <D.25740>, case 21: <D.25747>, case 22: <D.25746>, case 24: <D.25732>, case 25: <D.25733>, case 27: <D.25735>, case 28: <D.25738>, case 29: <D.25739>, case 30: <D.25749>>
  <D.25723>:
  D.45348 = 1;
  return D.45348;
  <D.25724>:
  <D.25725>:
  <D.25726>:
  <D.25727>:
  <D.25728>:
  <D.25729>:
  <D.25730>:
  <D.25731>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 1) goto <D.45366>; else goto <D.45367>;
  <D.45366>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 3) goto <D.45368>; else goto <D.45369>;
  <D.45368>:
  D.45348 = 1;
  return D.45348;
  <D.45369>:
  <D.45367>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25732>:
  <D.25733>:
  <D.25734>:
  <D.25735>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 1) goto <D.45370>; else goto <D.45371>;
  <D.45370>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 3) goto <D.45372>; else goto <D.45373>;
  <D.45372>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 5) goto <D.45374>; else goto <D.45375>;
  <D.45374>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 6) goto <D.45376>; else goto <D.45377>;
  <D.45376>:
  D.45348 = 1;
  return D.45348;
  <D.45377>:
  <D.45375>:
  <D.45373>:
  <D.45371>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25736>:
  <D.25737>:
  <D.25738>:
  <D.25739>:
  <D.25740>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 6) goto <D.45378>; else goto <D.45379>;
  <D.45378>:
  D.45348 = 1;
  return D.45348;
  <D.45379>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25741>:
  <D.25742>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 2) goto <D.45380>; else goto <D.45381>;
  <D.45380>:
  D.45348 = 1;
  return D.45348;
  <D.45381>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25743>:
  <D.25744>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 4) goto <D.45382>; else goto <D.45383>;
  <D.45382>:
  D.45348 = 1;
  return D.45348;
  <D.45383>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25745>:
  D.45384 = simple_type->data.klass;
  D.45385 = BIT_FIELD_REF <*D.45384, 64, 256>;
  D.45386 = D.45385 & 16;
  if (D.45386 != 0) goto <D.45387>; else goto <D.45388>;
  <D.45387>:
  D.45384 = simple_type->data.klass;
  simple_type = mono_class_enum_basetype (D.45384);
  goto handle_enum;
  <D.45388>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 7) goto <D.45389>; else goto <D.45390>;
  <D.45389>:
  D.45348 = 1;
  return D.45348;
  <D.45390>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25746>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 7) goto <D.45391>; else goto <D.45392>;
  <D.45391>:
  D.45348 = 1;
  return D.45348;
  <D.45392>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25747>:
  D.45393 = simple_type->data.generic_class;
  D.45394 = D.45393->container_class;
  simple_type = &D.45394->byval_arg;
  goto handle_enum;
  <D.25748>:
  <D.25749>:
  D.45354 = (long unsigned int) i;
  D.45355 = D.45354 * 8;
  D.45356 = args + D.45355;
  D.45357 = *D.45356;
  D.45358 = D.45357->type;
  if (D.45358 != 7) goto <D.45395>; else goto <D.45396>;
  <D.45395>:
  D.45348 = 1;
  return D.45348;
  <D.45396>:
  // predicted unlikely by continue predictor.
  goto <D.25721>;
  <D.25750>:
  D.45364 = simple_type->type;
  D.45365 = (int) D.45364;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in check_call_signature", D.45365);
  <D.25751>:
  goto <D.25751>;
  <D.25721>:
  i = i + 1;
  <D.25753>:
  D.45397 = sig->param_count;
  D.45398 = (int) D.45397;
  if (D.45398 > i) goto <D.25752>; else goto <D.25754>;
  <D.25754>:
  D.45348 = 0;
  return D.45348;
}


handle_array_new (struct MonoCompile * cfg, int rank, struct MonoInst * * sp, unsigned char * ip)
{
  unsigned int D.45400;
  unsigned int D.45401;
  struct MonoInst * D.45402;
  const void * D.45403;
  struct MonoMethodSignature * D.45404;
  struct MonoJitICallInfo * info;

  info = mono_get_array_new_va_icall (rank);
  D.45400 = cfg->flags;
  D.45401 = D.45400 | 8;
  cfg->flags = D.45401;
  cfg->disable_llvm = 1;
  D.45403 = mono_icall_get_wrapper (info);
  D.45404 = info->sig;
  D.45402 = mono_emit_native_call (cfg, D.45403, D.45404, sp);
  return D.45402;
}


emit_init_rvar (struct MonoCompile * cfg, int dreg, struct MonoType * rtype)
{
  unsigned char D.45406;
  long unsigned int D.45407;
  long unsigned int D.45408;
  struct MonoMemPool * D.45411;
  long int D.45412;
  struct MonoInst * D.45413;
  int D.45414;
  int D.45415;
  const unsigned char * D.45416;
  struct MonoBasicBlock * D.45417;
  struct MonoInst * D.45418;
  unsigned int t.414;
  unsigned int D.45424;
  long int D.45427;
  struct MonoInst * D.45428;
  int D.45429;
  int D.45430;
  unsigned int D.45435;
  long int D.45438;
  struct MonoInst * D.45439;
  int D.45440;
  int D.45441;
  unsigned int D.45446;
  long int D.45449;
  struct MonoInst * D.45450;
  int D.45451;
  int D.45452;
  int D.45463;
  long int D.45464;
  struct MonoInst * D.45465;
  int D.45466;
  int D.45467;
  struct MonoClass * D.45468;
  int D.45476;
  long int D.45478;
  struct MonoInst * D.45479;
  int D.45480;
  int D.45481;
  struct MonoClass * D.45482;
  long int D.45486;
  struct MonoInst * D.45487;
  int D.45488;
  int D.45489;
  static double r8_0 = 0.0;
  struct MonoInst * ins;
  int t;

  rtype = mini_replace_type (rtype);
  D.45406 = rtype->type;
  t = (int) D.45406;
  D.45407 = BIT_FIELD_REF <*rtype, 64, 64>;
  D.45408 = D.45407 & 1073741824;
  if (D.45408 != 0) goto <D.45409>; else goto <D.45410>;
  <D.45409>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45412 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45412;
    inst->prev = 0B;
    D.45413 = inst->prev;
    inst->next = D.45413;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45414 = inst->sreg3;
    inst->sreg2 = D.45414;
    D.45415 = inst->sreg2;
    inst->sreg1 = D.45415;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45419>; else goto <D.45420>;
    <D.45419>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45421>;
    <D.45420>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45421>:
  }
  goto <D.45422>;
  <D.45410>:
  t.414 = (unsigned int) t;
  D.45424 = t.414 + 4294967294;
  if (D.45424 <= 7) goto <D.45425>; else goto <D.45426>;
  <D.45425>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45427 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45427;
    inst->prev = 0B;
    D.45428 = inst->prev;
    inst->next = D.45428;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45429 = inst->sreg3;
    inst->sreg2 = D.45429;
    D.45430 = inst->sreg2;
    inst->sreg1 = D.45430;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45431>; else goto <D.45432>;
    <D.45431>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45433>;
    <D.45432>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45433>:
  }
  goto <D.45434>;
  <D.45426>:
  t.414 = (unsigned int) t;
  D.45435 = t.414 + 4294967286;
  if (D.45435 <= 1) goto <D.45436>; else goto <D.45437>;
  <D.45436>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45438 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45438;
    inst->prev = 0B;
    D.45439 = inst->prev;
    inst->next = D.45439;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45440 = inst->sreg3;
    inst->sreg2 = D.45440;
    D.45441 = inst->sreg2;
    inst->sreg1 = D.45441;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->data.i8const = 0;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45442>; else goto <D.45443>;
    <D.45442>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45444>;
    <D.45443>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45444>:
  }
  goto <D.45445>;
  <D.45437>:
  t.414 = (unsigned int) t;
  D.45446 = t.414 + 4294967284;
  if (D.45446 <= 1) goto <D.45447>; else goto <D.45448>;
  <D.45447>:
  D.45411 = cfg->mempool;
  ins = mono_mempool_alloc (D.45411, 80);
  ins->data.op[1].const_val = 0;
  D.45449 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.45449;
  ins->prev = 0B;
  D.45450 = ins->prev;
  ins->next = D.45450;
  ins->opcode = 365;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.45451 = ins->sreg3;
  ins->sreg2 = D.45451;
  D.45452 = ins->sreg2;
  ins->sreg1 = D.45452;
  D.45416 = cfg->ip;
  ins->cil_code = D.45416;
  ins->type = 4;
  ins->data.op[0].p = &r8_0;
  ins->dreg = dreg;
  D.45417 = cfg->cbb;
  D.45418 = D.45417->last_ins;
  if (D.45418 != 0B) goto <D.45453>; else goto <D.45454>;
  <D.45453>:
  D.45417 = cfg->cbb;
  D.45418 = D.45417->last_ins;
  D.45418->next = ins;
  D.45417 = cfg->cbb;
  D.45418 = D.45417->last_ins;
  ins->prev = D.45418;
  D.45417 = cfg->cbb;
  D.45417->last_ins = ins;
  goto <D.45455>;
  <D.45454>:
  D.45417 = cfg->cbb;
  D.45417 = cfg->cbb;
  D.45417->last_ins = ins;
  D.45418 = D.45417->last_ins;
  D.45417->code = D.45418;
  <D.45455>:
  goto <D.45456>;
  <D.45448>:
  if (t == 17) goto <D.45457>; else goto <D.45460>;
  <D.45460>:
  if (t == 22) goto <D.45457>; else goto <D.45461>;
  <D.45461>:
  if (t == 21) goto <D.45462>; else goto <D.45458>;
  <D.45462>:
  D.45463 = mono_type_generic_inst_is_valuetype (rtype);
  if (D.45463 != 0) goto <D.45457>; else goto <D.45458>;
  <D.45457>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45464 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45464;
    inst->prev = 0B;
    D.45465 = inst->prev;
    inst->next = D.45465;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45466 = inst->sreg3;
    inst->sreg2 = D.45466;
    D.45467 = inst->sreg2;
    inst->sreg1 = D.45467;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->type = 7;
    D.45468 = mono_class_from_mono_type (rtype);
    inst->klass = D.45468;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45469>; else goto <D.45470>;
    <D.45469>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45471>;
    <D.45470>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45471>:
  }
  goto <D.45459>;
  <D.45458>:
  if (t == 19) goto <D.45472>; else goto <D.45475>;
  <D.45475>:
  if (t == 30) goto <D.45472>; else goto <D.45473>;
  <D.45472>:
  D.45476 = mini_type_var_is_vt (cfg, rtype);
  if (D.45476 != 0) goto <D.45477>; else goto <D.45473>;
  <D.45477>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45478 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45478;
    inst->prev = 0B;
    D.45479 = inst->prev;
    inst->next = D.45479;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45480 = inst->sreg3;
    inst->sreg2 = D.45480;
    D.45481 = inst->sreg2;
    inst->sreg1 = D.45481;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->type = 7;
    D.45482 = mono_class_from_mono_type (rtype);
    inst->klass = D.45482;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45483>; else goto <D.45484>;
    <D.45483>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45485>;
    <D.45484>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45485>:
  }
  goto <D.45474>;
  <D.45473>:
  {
    struct MonoInst * inst;

    D.45411 = cfg->mempool;
    inst = mono_mempool_alloc (D.45411, 80);
    inst->data.op[1].const_val = 0;
    D.45486 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45486;
    inst->prev = 0B;
    D.45487 = inst->prev;
    inst->next = D.45487;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45488 = inst->sreg3;
    inst->sreg2 = D.45488;
    D.45489 = inst->sreg2;
    inst->sreg1 = D.45489;
    D.45416 = cfg->ip;
    inst->cil_code = D.45416;
    inst->dreg = dreg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    if (D.45418 != 0B) goto <D.45490>; else goto <D.45491>;
    <D.45490>:
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    D.45418->next = inst;
    D.45417 = cfg->cbb;
    D.45418 = D.45417->last_ins;
    inst->prev = D.45418;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    goto <D.45492>;
    <D.45491>:
    D.45417 = cfg->cbb;
    D.45417 = cfg->cbb;
    D.45417->last_ins = inst;
    D.45418 = D.45417->last_ins;
    D.45417->code = D.45418;
    <D.45492>:
  }
  <D.45474>:
  <D.45459>:
  <D.45456>:
  <D.45445>:
  <D.45434>:
  <D.45422>:
}


handle_alloc (struct MonoCompile * cfg, struct MonoClass * klass, gboolean for_box, int context_used)
{
  unsigned int D.45495;
  unsigned int D.45496;
  <unnamed type> rgctx_info.415;
  long unsigned int D.45507;
  long unsigned int D.45508;
  struct MonoMemPool * D.45509;
  void * D.45510;
  struct MonoInst * D.45511;
  long int D.45512;
  struct MonoInst * D.45513;
  int D.45514;
  int D.45515;
  const unsigned char * D.45516;
  struct MonoInst * * D.45517;
  long int D.45518;
  long unsigned int D.45519;
  long unsigned int D.45520;
  struct MonoInst * * D.45521;
  struct MonoInst * D.45522;
  struct MonoType * D.45523;
  unsigned int D.45524;
  short unsigned int D.45525;
  struct MonoClass * D.45526;
  int D.45527;
  unsigned char D.45528;
  <unnamed type> D.45529;
  unsigned int D.45530;
  int D.45531;
  short unsigned int D.45532;
  struct MonoClass * D.45535;
  void * D.45536;
  struct MonoDomain * D.45537;
  unsigned int D.45538;
  int D.45539;
  struct MonoBasicBlock * D.45540;
  struct MonoInst * D.45541;
  struct MonoInst * D.45550;
  void * D.45557;
  struct MonoInst * D.45558;
  long int D.45559;
  struct MonoInst * D.45560;
  int D.45561;
  int D.45562;
  long int D.45563;
  long unsigned int D.45564;
  long unsigned int D.45565;
  struct MonoInst * * D.45566;
  struct MonoInst * D.45567;
  struct MonoType * D.45568;
  unsigned int D.45569;
  short unsigned int D.45570;
  struct MonoClass * D.45571;
  int D.45572;
  unsigned char D.45573;
  <unnamed type> D.45574;
  unsigned int D.45575;
  int D.45576;
  short unsigned int D.45577;
  struct MonoClass * D.45580;
  void * D.45581;
  unsigned int D.45582;
  int D.45583;
  void * D.45587;
  struct MonoInst * D.45588;
  long int D.45589;
  struct MonoInst * D.45590;
  guint16 iftmp.416;
  int D.45595;
  int D.45596;
  long int D.45599;
  struct MonoInst * D.45600;
  int D.45601;
  int D.45602;
  int D.45603;
  unsigned int D.45605;
  int D.45606;
  long unsigned int D.45613;
  long unsigned int D.45614;
  unsigned int D.45616;
  struct MonoImage * D.45618;
  struct MonoImage * D.45619;
  struct MonoGenericClass * D.45621;
  void * D.45623;
  long int D.45624;
  long int D.45625;
  unsigned int D.45626;
  int D.45627;
  void * D.45635;
  guint16 iftmp.417;
  long int D.45642;
  struct MonoInst * D.45643;
  int D.45644;
  int D.45645;
  struct MonoInst * iftmp.418;
  int D.45650;
  void * iftmp.419;
  unsigned int D.45656;
  int D.45657;
  int pass_lw.420;
  struct MonoClass * D.45664;
  int D.45665;
  long unsigned int D.45666;
  long unsigned int D.45667;
  long unsigned int D.45668;
  long unsigned int D.45669;
  void * D.45670;
  long int D.45671;
  unsigned int D.45672;
  int D.45673;
  void * D.45677;
  guint16 iftmp.421;
  long int D.45684;
  struct MonoInst * D.45685;
  int D.45686;
  int D.45687;
  struct MonoInst * iftmp.422;
  int D.45692;
  void * iftmp.423;
  unsigned int D.45698;
  int D.45699;
  void * D.45704;
  guint16 iftmp.424;
  long int D.45711;
  struct MonoInst * D.45712;
  int D.45713;
  int D.45714;
  struct MonoInst * iftmp.425;
  int D.45719;
  void * iftmp.426;
  unsigned int D.45725;
  int D.45726;
  struct MonoInst * iargs[2];
  void * alloc_ftn;

  try
    {
      if (context_used != 0) goto <D.45493>; else goto <D.45494>;
      <D.45493>:
      {
        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.45495 = cfg->opt;
            D.45496 = D.45495 & 512;
            if (D.45496 != 0) goto <D.45497>; else goto <D.45498>;
            <D.45497>:
            rgctx_info = 1;
            goto <D.45499>;
            <D.45498>:
            rgctx_info = 2;
            <D.45499>:
            rgctx_info.415 = (<unnamed type>) rgctx_info;
            data = emit_get_rgctx_klass (cfg, context_used, klass, rgctx_info.415);
            D.45495 = cfg->opt;
            D.45496 = D.45495 & 512;
            if (D.45496 != 0) goto <D.45501>; else goto <D.45502>;
            <D.45501>:
            D.45495 = cfg->opt;
            D.45496 = D.45495 & 512;
            if (D.45496 != 0) goto <D.45503>; else goto <D.45506>;
            <D.45506>:
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45503>; else goto <D.45504>;
            <D.45503>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.45509 = cfg->mempool;
              D.45510 = mono_mempool_alloc (D.45509, 80);
              iargs[0] = D.45510;
              D.45511 = iargs[0];
              D.45511 = iargs[0];
              D.45511->data.op[1].const_val = 0;
              D.45512 = D.45511->data.op[1].const_val;
              D.45511->data.op[0].const_val = D.45512;
              D.45511 = iargs[0];
              D.45511 = iargs[0];
              D.45511->prev = 0B;
              D.45513 = D.45511->prev;
              D.45511->next = D.45513;
              D.45511 = iargs[0];
              D.45511->opcode = 424;
              D.45511 = iargs[0];
              D.45511->flags = 0;
              D.45511 = iargs[0];
              D.45511->type = 0;
              D.45511 = iargs[0];
              D.45511->dreg = -1;
              D.45511 = iargs[0];
              D.45511 = iargs[0];
              D.45511 = iargs[0];
              D.45511->sreg3 = -1;
              D.45514 = D.45511->sreg3;
              D.45511->sreg2 = D.45514;
              D.45515 = D.45511->sreg2;
              D.45511->sreg1 = D.45515;
              D.45511 = iargs[0];
              D.45516 = cfg->ip;
              D.45511->cil_code = D.45516;
              D.45511 = iargs[0];
              D.45517 = cfg->varinfo;
              D.45518 = __domain_var->data.op[0].const_val;
              D.45519 = (long unsigned int) D.45518;
              D.45520 = D.45519 * 8;
              D.45521 = D.45517 + D.45520;
              D.45522 = *D.45521;
              D.45523 = D.45522->data.op[1].vtype;
              D.45524 = mono_type_to_regmove (cfg, D.45523);
              D.45525 = (short unsigned int) D.45524;
              D.45511->opcode = D.45525;
              D.45517 = cfg->varinfo;
              D.45518 = __domain_var->data.op[0].const_val;
              D.45519 = (long unsigned int) D.45518;
              D.45520 = D.45519 * 8;
              D.45521 = D.45517 + D.45520;
              D.45522 = *D.45521;
              D.45523 = D.45522->data.op[1].vtype;
              D.45511 = iargs[0];
              type_to_eval_stack_type (cfg, D.45523, D.45511);
              D.45511 = iargs[0];
              D.45517 = cfg->varinfo;
              D.45518 = __domain_var->data.op[0].const_val;
              D.45519 = (long unsigned int) D.45518;
              D.45520 = D.45519 * 8;
              D.45521 = D.45517 + D.45520;
              D.45522 = *D.45521;
              D.45526 = D.45522->klass;
              D.45511->klass = D.45526;
              D.45511 = iargs[0];
              D.45517 = cfg->varinfo;
              D.45518 = __domain_var->data.op[0].const_val;
              D.45519 = (long unsigned int) D.45518;
              D.45520 = D.45519 * 8;
              D.45521 = D.45517 + D.45520;
              D.45522 = *D.45521;
              D.45527 = D.45522->dreg;
              D.45511->sreg1 = D.45527;
              D.45511 = iargs[0];
              D.45511 = iargs[0];
              D.45528 = D.45511->type;
              D.45529 = (<unnamed type>) D.45528;
              D.45530 = alloc_dreg (cfg, D.45529);
              D.45531 = (int) D.45530;
              D.45511->dreg = D.45531;
              D.45511 = iargs[0];
              D.45532 = D.45511->opcode;
              if (D.45532 == 427) goto <D.45533>; else goto <D.45534>;
              <D.45533>:
              D.45511 = iargs[0];
              D.45517 = cfg->varinfo;
              D.45518 = __domain_var->data.op[0].const_val;
              D.45519 = (long unsigned int) D.45518;
              D.45520 = D.45519 * 8;
              D.45521 = D.45517 + D.45520;
              D.45522 = *D.45521;
              D.45523 = D.45522->data.op[1].vtype;
              D.45535 = mono_class_from_mono_type (D.45523);
              D.45511->klass = D.45535;
              <D.45534>:
            }
            goto <D.45505>;
            <D.45504>:
            D.45509 = cfg->mempool;
            D.45536 = mono_mempool_alloc (D.45509, 80);
            iargs[0] = D.45536;
            D.45511 = iargs[0];
            D.45511 = iargs[0];
            D.45511->data.op[1].const_val = 0;
            D.45512 = D.45511->data.op[1].const_val;
            D.45511->data.op[0].const_val = D.45512;
            D.45511 = iargs[0];
            D.45511 = iargs[0];
            D.45511->prev = 0B;
            D.45513 = D.45511->prev;
            D.45511->next = D.45513;
            D.45511 = iargs[0];
            D.45511->opcode = 363;
            D.45511 = iargs[0];
            D.45511->flags = 0;
            D.45511 = iargs[0];
            D.45511->type = 0;
            D.45511 = iargs[0];
            D.45511->dreg = -1;
            D.45511 = iargs[0];
            D.45511 = iargs[0];
            D.45511 = iargs[0];
            D.45511->sreg3 = -1;
            D.45514 = D.45511->sreg3;
            D.45511->sreg2 = D.45514;
            D.45515 = D.45511->sreg2;
            D.45511->sreg1 = D.45515;
            D.45511 = iargs[0];
            D.45516 = cfg->ip;
            D.45511->cil_code = D.45516;
            D.45511 = iargs[0];
            D.45537 = cfg->domain;
            D.45511->data.op[0].p = D.45537;
            D.45511 = iargs[0];
            D.45511->type = 3;
            D.45511 = iargs[0];
            D.45538 = alloc_dreg (cfg, 3);
            D.45539 = (int) D.45538;
            D.45511->dreg = D.45539;
            <D.45505>:
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            if (D.45541 != 0B) goto <D.45542>; else goto <D.45543>;
            <D.45542>:
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45511 = iargs[0];
            D.45541->next = D.45511;
            D.45511 = iargs[0];
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45511->prev = D.45541;
            D.45540 = cfg->cbb;
            D.45511 = iargs[0];
            D.45540->last_ins = D.45511;
            goto <D.45544>;
            <D.45543>:
            D.45540 = cfg->cbb;
            D.45540 = cfg->cbb;
            D.45511 = iargs[0];
            D.45540->last_ins = D.45511;
            D.45541 = D.45540->last_ins;
            D.45540->code = D.45541;
            <D.45544>:
            iargs[1] = data;
            alloc_ftn = mono_object_new;
            goto <D.45545>;
            <D.45502>:
            iargs[0] = data;
            alloc_ftn = mono_object_new_specific;
            <D.45545>:
            if (managed_alloc != 0B) goto <D.45546>; else goto <D.45547>;
            <D.45546>:
            D.45495 = cfg->opt;
            D.45496 = D.45495 & 512;
            if (D.45496 == 0) goto <D.45548>; else goto <D.45549>;
            <D.45548>:
            D.45550 = mono_emit_method_call (cfg, managed_alloc, &iargs, 0B);
            return D.45550;
            <D.45549>:
            <D.45547>:
            D.45550 = mono_emit_jit_icall (cfg, alloc_ftn, &iargs);
            return D.45550;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.45494>:
      D.45495 = cfg->opt;
      D.45496 = D.45495 & 512;
      if (D.45496 != 0) goto <D.45551>; else goto <D.45552>;
      <D.45551>:
      D.45495 = cfg->opt;
      D.45496 = D.45495 & 512;
      if (D.45496 != 0) goto <D.45553>; else goto <D.45556>;
      <D.45556>:
      D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45508 = D.45507 & 274877906944;
      if (D.45508 != 0) goto <D.45553>; else goto <D.45554>;
      <D.45553>:
      {
        struct MonoInst * __domain_var;

        __domain_var = mono_get_domainvar (cfg);
        D.45509 = cfg->mempool;
        D.45557 = mono_mempool_alloc (D.45509, 80);
        iargs[0] = D.45557;
        D.45558 = iargs[0];
        D.45558 = iargs[0];
        D.45558->data.op[1].const_val = 0;
        D.45559 = D.45558->data.op[1].const_val;
        D.45558->data.op[0].const_val = D.45559;
        D.45558 = iargs[0];
        D.45558 = iargs[0];
        D.45558->prev = 0B;
        D.45560 = D.45558->prev;
        D.45558->next = D.45560;
        D.45558 = iargs[0];
        D.45558->opcode = 424;
        D.45558 = iargs[0];
        D.45558->flags = 0;
        D.45558 = iargs[0];
        D.45558->type = 0;
        D.45558 = iargs[0];
        D.45558->dreg = -1;
        D.45558 = iargs[0];
        D.45558 = iargs[0];
        D.45558 = iargs[0];
        D.45558->sreg3 = -1;
        D.45561 = D.45558->sreg3;
        D.45558->sreg2 = D.45561;
        D.45562 = D.45558->sreg2;
        D.45558->sreg1 = D.45562;
        D.45558 = iargs[0];
        D.45516 = cfg->ip;
        D.45558->cil_code = D.45516;
        D.45558 = iargs[0];
        D.45517 = cfg->varinfo;
        D.45563 = __domain_var->data.op[0].const_val;
        D.45564 = (long unsigned int) D.45563;
        D.45565 = D.45564 * 8;
        D.45566 = D.45517 + D.45565;
        D.45567 = *D.45566;
        D.45568 = D.45567->data.op[1].vtype;
        D.45569 = mono_type_to_regmove (cfg, D.45568);
        D.45570 = (short unsigned int) D.45569;
        D.45558->opcode = D.45570;
        D.45517 = cfg->varinfo;
        D.45563 = __domain_var->data.op[0].const_val;
        D.45564 = (long unsigned int) D.45563;
        D.45565 = D.45564 * 8;
        D.45566 = D.45517 + D.45565;
        D.45567 = *D.45566;
        D.45568 = D.45567->data.op[1].vtype;
        D.45558 = iargs[0];
        type_to_eval_stack_type (cfg, D.45568, D.45558);
        D.45558 = iargs[0];
        D.45517 = cfg->varinfo;
        D.45563 = __domain_var->data.op[0].const_val;
        D.45564 = (long unsigned int) D.45563;
        D.45565 = D.45564 * 8;
        D.45566 = D.45517 + D.45565;
        D.45567 = *D.45566;
        D.45571 = D.45567->klass;
        D.45558->klass = D.45571;
        D.45558 = iargs[0];
        D.45517 = cfg->varinfo;
        D.45563 = __domain_var->data.op[0].const_val;
        D.45564 = (long unsigned int) D.45563;
        D.45565 = D.45564 * 8;
        D.45566 = D.45517 + D.45565;
        D.45567 = *D.45566;
        D.45572 = D.45567->dreg;
        D.45558->sreg1 = D.45572;
        D.45558 = iargs[0];
        D.45558 = iargs[0];
        D.45573 = D.45558->type;
        D.45574 = (<unnamed type>) D.45573;
        D.45575 = alloc_dreg (cfg, D.45574);
        D.45576 = (int) D.45575;
        D.45558->dreg = D.45576;
        D.45558 = iargs[0];
        D.45577 = D.45558->opcode;
        if (D.45577 == 427) goto <D.45578>; else goto <D.45579>;
        <D.45578>:
        D.45558 = iargs[0];
        D.45517 = cfg->varinfo;
        D.45563 = __domain_var->data.op[0].const_val;
        D.45564 = (long unsigned int) D.45563;
        D.45565 = D.45564 * 8;
        D.45566 = D.45517 + D.45565;
        D.45567 = *D.45566;
        D.45568 = D.45567->data.op[1].vtype;
        D.45580 = mono_class_from_mono_type (D.45568);
        D.45558->klass = D.45580;
        <D.45579>:
      }
      goto <D.45555>;
      <D.45554>:
      D.45509 = cfg->mempool;
      D.45581 = mono_mempool_alloc (D.45509, 80);
      iargs[0] = D.45581;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->data.op[1].const_val = 0;
      D.45559 = D.45558->data.op[1].const_val;
      D.45558->data.op[0].const_val = D.45559;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->prev = 0B;
      D.45560 = D.45558->prev;
      D.45558->next = D.45560;
      D.45558 = iargs[0];
      D.45558->opcode = 363;
      D.45558 = iargs[0];
      D.45558->flags = 0;
      D.45558 = iargs[0];
      D.45558->type = 0;
      D.45558 = iargs[0];
      D.45558->dreg = -1;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->sreg3 = -1;
      D.45561 = D.45558->sreg3;
      D.45558->sreg2 = D.45561;
      D.45562 = D.45558->sreg2;
      D.45558->sreg1 = D.45562;
      D.45558 = iargs[0];
      D.45516 = cfg->ip;
      D.45558->cil_code = D.45516;
      D.45558 = iargs[0];
      D.45537 = cfg->domain;
      D.45558->data.op[0].p = D.45537;
      D.45558 = iargs[0];
      D.45558->type = 3;
      D.45558 = iargs[0];
      D.45582 = alloc_dreg (cfg, 3);
      D.45583 = (int) D.45582;
      D.45558->dreg = D.45583;
      <D.45555>:
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      if (D.45541 != 0B) goto <D.45584>; else goto <D.45585>;
      <D.45584>:
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45558 = iargs[0];
      D.45541->next = D.45558;
      D.45558 = iargs[0];
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45558->prev = D.45541;
      D.45540 = cfg->cbb;
      D.45558 = iargs[0];
      D.45540->last_ins = D.45558;
      goto <D.45586>;
      <D.45585>:
      D.45540 = cfg->cbb;
      D.45540 = cfg->cbb;
      D.45558 = iargs[0];
      D.45540->last_ins = D.45558;
      D.45541 = D.45540->last_ins;
      D.45540->code = D.45541;
      <D.45586>:
      D.45509 = cfg->mempool;
      D.45587 = mono_mempool_alloc (D.45509, 80);
      iargs[1] = D.45587;
      D.45588 = iargs[1];
      D.45588 = iargs[1];
      D.45588->data.op[1].const_val = 0;
      D.45589 = D.45588->data.op[1].const_val;
      D.45588->data.op[0].const_val = D.45589;
      D.45588 = iargs[1];
      D.45588 = iargs[1];
      D.45588->prev = 0B;
      D.45590 = D.45588->prev;
      D.45588->next = D.45590;
      D.45588 = iargs[1];
      D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45508 = D.45507 & 274877906944;
      if (D.45508 != 0) goto <D.45592>; else goto <D.45593>;
      <D.45592>:
      iftmp.416 = 734;
      goto <D.45594>;
      <D.45593>:
      iftmp.416 = 363;
      <D.45594>:
      D.45588->opcode = iftmp.416;
      D.45588 = iargs[1];
      D.45588->flags = 0;
      D.45588 = iargs[1];
      D.45588->type = 0;
      D.45588 = iargs[1];
      D.45588->dreg = -1;
      D.45588 = iargs[1];
      D.45588 = iargs[1];
      D.45588 = iargs[1];
      D.45588->sreg3 = -1;
      D.45595 = D.45588->sreg3;
      D.45588->sreg2 = D.45595;
      D.45596 = D.45588->sreg2;
      D.45588->sreg1 = D.45596;
      D.45588 = iargs[1];
      D.45516 = cfg->ip;
      D.45588->cil_code = D.45516;
      D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45508 = D.45507 & 274877906944;
      if (D.45508 != 0) goto <D.45597>; else goto <D.45598>;
      <D.45597>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.45509 = cfg->mempool;
        group = mono_mempool_alloc (D.45509, 80);
        group->data.op[1].const_val = 0;
        D.45599 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.45599;
        group->prev = 0B;
        D.45600 = group->prev;
        group->next = D.45600;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.45601 = group->sreg3;
        group->sreg2 = D.45601;
        D.45602 = group->sreg2;
        group->sreg1 = D.45602;
        D.45516 = cfg->ip;
        group->cil_code = D.45516;
        group->data.op[0].src = klass;
        group->data.op[1].src = 11B;
        D.45588 = iargs[1];
        D.45603 = got_loc->dreg;
        D.45588->sreg1 = D.45603;
        D.45588 = iargs[1];
        D.45588->data.op[1].p = group;
      }
      goto <D.45604>;
      <D.45598>:
      D.45588 = iargs[1];
      D.45588->data.op[0].p = klass;
      D.45588 = iargs[1];
      D.45588->data.op[1].src = 11B;
      <D.45604>:
      D.45588 = iargs[1];
      D.45588->type = 3;
      D.45588 = iargs[1];
      D.45605 = alloc_dreg (cfg, 3);
      D.45606 = (int) D.45605;
      D.45588->dreg = D.45606;
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      if (D.45541 != 0B) goto <D.45607>; else goto <D.45608>;
      <D.45607>:
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45588 = iargs[1];
      D.45541->next = D.45588;
      D.45588 = iargs[1];
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45588->prev = D.45541;
      D.45540 = cfg->cbb;
      D.45588 = iargs[1];
      D.45540->last_ins = D.45588;
      goto <D.45609>;
      <D.45608>:
      D.45540 = cfg->cbb;
      D.45540 = cfg->cbb;
      D.45588 = iargs[1];
      D.45540->last_ins = D.45588;
      D.45541 = D.45540->last_ins;
      D.45540->code = D.45541;
      <D.45609>:
      alloc_ftn = mono_object_new;
      goto <D.45610>;
      <D.45552>:
      D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45508 = D.45507 & 274877906944;
      if (D.45508 != 0) goto <D.45612>; else goto <D.45611>;
      <D.45612>:
      D.45540 = cfg->cbb;
      D.45613 = BIT_FIELD_REF <*D.45540, 64, 1472>;
      D.45614 = D.45613 & 65536;
      if (D.45614 != 0) goto <D.45615>; else goto <D.45611>;
      <D.45615>:
      D.45616 = klass->type_token;
      if (D.45616 != 0) goto <D.45617>; else goto <D.45611>;
      <D.45617>:
      D.45618 = klass->image;
      D.45619 = mono_defaults.corlib;
      if (D.45618 == D.45619) goto <D.45620>; else goto <D.45611>;
      <D.45620>:
      D.45621 = klass->generic_class;
      if (D.45621 == 0B) goto <D.45622>; else goto <D.45611>;
      <D.45622>:
      D.45509 = cfg->mempool;
      D.45623 = mono_mempool_alloc (D.45509, 80);
      iargs[0] = D.45623;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->data.op[1].const_val = 0;
      D.45559 = D.45558->data.op[1].const_val;
      D.45558->data.op[0].const_val = D.45559;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->prev = 0B;
      D.45560 = D.45558->prev;
      D.45558->next = D.45560;
      D.45558 = iargs[0];
      D.45558->opcode = 362;
      D.45558 = iargs[0];
      D.45558->flags = 0;
      D.45558 = iargs[0];
      D.45558->type = 0;
      D.45558 = iargs[0];
      D.45558->dreg = -1;
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558 = iargs[0];
      D.45558->sreg3 = -1;
      D.45561 = D.45558->sreg3;
      D.45558->sreg2 = D.45561;
      D.45562 = D.45558->sreg2;
      D.45558->sreg1 = D.45562;
      D.45558 = iargs[0];
      D.45516 = cfg->ip;
      D.45558->cil_code = D.45516;
      D.45558 = iargs[0];
      D.45616 = klass->type_token;
      D.45624 = (long int) D.45616;
      D.45625 = D.45624 & 16777215;
      D.45558->data.op[0].const_val = D.45625;
      D.45558 = iargs[0];
      D.45558->type = 1;
      D.45558 = iargs[0];
      D.45626 = alloc_dreg (cfg, 1);
      D.45627 = (int) D.45626;
      D.45558->dreg = D.45627;
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      if (D.45541 != 0B) goto <D.45628>; else goto <D.45629>;
      <D.45628>:
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45558 = iargs[0];
      D.45541->next = D.45558;
      D.45558 = iargs[0];
      D.45540 = cfg->cbb;
      D.45541 = D.45540->last_ins;
      D.45558->prev = D.45541;
      D.45540 = cfg->cbb;
      D.45558 = iargs[0];
      D.45540->last_ins = D.45558;
      goto <D.45630>;
      <D.45629>:
      D.45540 = cfg->cbb;
      D.45540 = cfg->cbb;
      D.45558 = iargs[0];
      D.45540->last_ins = D.45558;
      D.45541 = D.45540->last_ins;
      D.45540->code = D.45541;
      <D.45630>:
      D.45550 = mono_emit_jit_icall (cfg, mono_helper_newobj_mscorlib, &iargs);
      return D.45550;
      <D.45611>:
      {
        struct MonoVTable * vtable;
        struct MonoMethod * managed_alloc;
        gboolean pass_lw;

        try
          {
            D.45537 = cfg->domain;
            vtable = mono_class_vtable (D.45537, klass);
            managed_alloc = 0B;
            if (vtable == 0B) goto <D.45631>; else goto <D.45632>;
            <D.45631>:
            mono_cfg_set_exception (cfg, 7);
            cfg->exception_ptr = klass;
            D.45550 = 0B;
            return D.45550;
            <D.45632>:
            managed_alloc = mono_gc_get_managed_allocator (klass, for_box);
            if (managed_alloc != 0B) goto <D.45633>; else goto <D.45634>;
            <D.45633>:
            D.45509 = cfg->mempool;
            D.45635 = mono_mempool_alloc (D.45509, 80);
            iargs[0] = D.45635;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->data.op[1].const_val = 0;
            D.45559 = D.45558->data.op[1].const_val;
            D.45558->data.op[0].const_val = D.45559;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->prev = 0B;
            D.45560 = D.45558->prev;
            D.45558->next = D.45560;
            D.45558 = iargs[0];
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45637>; else goto <D.45638>;
            <D.45637>:
            iftmp.417 = 734;
            goto <D.45639>;
            <D.45638>:
            iftmp.417 = 363;
            <D.45639>:
            D.45558->opcode = iftmp.417;
            D.45558 = iargs[0];
            D.45558->flags = 0;
            D.45558 = iargs[0];
            D.45558->type = 0;
            D.45558 = iargs[0];
            D.45558->dreg = -1;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->sreg3 = -1;
            D.45561 = D.45558->sreg3;
            D.45558->sreg2 = D.45561;
            D.45562 = D.45558->sreg2;
            D.45558->sreg1 = D.45562;
            D.45558 = iargs[0];
            D.45516 = cfg->ip;
            D.45558->cil_code = D.45516;
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45640>; else goto <D.45641>;
            <D.45640>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.45509 = cfg->mempool;
              group = mono_mempool_alloc (D.45509, 80);
              group->data.op[1].const_val = 0;
              D.45642 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.45642;
              group->prev = 0B;
              D.45643 = group->prev;
              group->next = D.45643;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.45644 = group->sreg3;
              group->sreg2 = D.45644;
              D.45645 = group->sreg2;
              group->sreg1 = D.45645;
              D.45516 = cfg->ip;
              group->cil_code = D.45516;
              D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.45508 = D.45507 & 274877906944;
              if (D.45508 != 0) goto <D.45647>; else goto <D.45648>;
              <D.45647>:
              iftmp.418 = vtable->klass;
              goto <D.45649>;
              <D.45648>:
              iftmp.418 = vtable;
              <D.45649>:
              group->data.op[0].src = iftmp.418;
              group->data.op[1].src = 14B;
              D.45558 = iargs[0];
              D.45650 = got_loc->dreg;
              D.45558->sreg1 = D.45650;
              D.45558 = iargs[0];
              D.45558->data.op[1].p = group;
            }
            goto <D.45651>;
            <D.45641>:
            D.45558 = iargs[0];
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45653>; else goto <D.45654>;
            <D.45653>:
            iftmp.419 = vtable->klass;
            goto <D.45655>;
            <D.45654>:
            iftmp.419 = vtable;
            <D.45655>:
            D.45558->data.op[0].p = iftmp.419;
            D.45558 = iargs[0];
            D.45558->data.op[1].src = 14B;
            <D.45651>:
            D.45558 = iargs[0];
            D.45558->type = 3;
            D.45558 = iargs[0];
            D.45656 = alloc_dreg (cfg, 3);
            D.45657 = (int) D.45656;
            D.45558->dreg = D.45657;
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            if (D.45541 != 0B) goto <D.45658>; else goto <D.45659>;
            <D.45658>:
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45558 = iargs[0];
            D.45541->next = D.45558;
            D.45558 = iargs[0];
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45558->prev = D.45541;
            D.45540 = cfg->cbb;
            D.45558 = iargs[0];
            D.45540->last_ins = D.45558;
            goto <D.45660>;
            <D.45659>:
            D.45540 = cfg->cbb;
            D.45540 = cfg->cbb;
            D.45558 = iargs[0];
            D.45540->last_ins = D.45558;
            D.45541 = D.45540->last_ins;
            D.45540->code = D.45541;
            <D.45660>:
            D.45550 = mono_emit_method_call (cfg, managed_alloc, &iargs, 0B);
            return D.45550;
            <D.45634>:
            alloc_ftn = mono_class_get_allocation_ftn (vtable, for_box, &pass_lw);
            pass_lw.420 = pass_lw;
            if (pass_lw.420 != 0) goto <D.45662>; else goto <D.45663>;
            <D.45662>:
            {
              guint32 lw;

              D.45664 = vtable->klass;
              D.45665 = D.45664->instance_size;
              lw = (guint32) D.45665;
              D.45666 = (long unsigned int) lw;
              D.45667 = D.45666 + 7;
              D.45668 = D.45667 & 18446744073709551608;
              D.45669 = D.45668 / 8;
              lw = (guint32) D.45669;
              D.45509 = cfg->mempool;
              D.45670 = mono_mempool_alloc (D.45509, 80);
              iargs[0] = D.45670;
              D.45558 = iargs[0];
              D.45558 = iargs[0];
              D.45558->data.op[1].const_val = 0;
              D.45559 = D.45558->data.op[1].const_val;
              D.45558->data.op[0].const_val = D.45559;
              D.45558 = iargs[0];
              D.45558 = iargs[0];
              D.45558->prev = 0B;
              D.45560 = D.45558->prev;
              D.45558->next = D.45560;
              D.45558 = iargs[0];
              D.45558->opcode = 362;
              D.45558 = iargs[0];
              D.45558->flags = 0;
              D.45558 = iargs[0];
              D.45558->type = 0;
              D.45558 = iargs[0];
              D.45558->dreg = -1;
              D.45558 = iargs[0];
              D.45558 = iargs[0];
              D.45558 = iargs[0];
              D.45558->sreg3 = -1;
              D.45561 = D.45558->sreg3;
              D.45558->sreg2 = D.45561;
              D.45562 = D.45558->sreg2;
              D.45558->sreg1 = D.45562;
              D.45558 = iargs[0];
              D.45516 = cfg->ip;
              D.45558->cil_code = D.45516;
              D.45558 = iargs[0];
              D.45671 = (long int) lw;
              D.45558->data.op[0].const_val = D.45671;
              D.45558 = iargs[0];
              D.45558->type = 1;
              D.45558 = iargs[0];
              D.45672 = alloc_dreg (cfg, 1);
              D.45673 = (int) D.45672;
              D.45558->dreg = D.45673;
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              if (D.45541 != 0B) goto <D.45674>; else goto <D.45675>;
              <D.45674>:
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              D.45558 = iargs[0];
              D.45541->next = D.45558;
              D.45558 = iargs[0];
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              D.45558->prev = D.45541;
              D.45540 = cfg->cbb;
              D.45558 = iargs[0];
              D.45540->last_ins = D.45558;
              goto <D.45676>;
              <D.45675>:
              D.45540 = cfg->cbb;
              D.45540 = cfg->cbb;
              D.45558 = iargs[0];
              D.45540->last_ins = D.45558;
              D.45541 = D.45540->last_ins;
              D.45540->code = D.45541;
              <D.45676>:
              D.45509 = cfg->mempool;
              D.45677 = mono_mempool_alloc (D.45509, 80);
              iargs[1] = D.45677;
              D.45588 = iargs[1];
              D.45588 = iargs[1];
              D.45588->data.op[1].const_val = 0;
              D.45589 = D.45588->data.op[1].const_val;
              D.45588->data.op[0].const_val = D.45589;
              D.45588 = iargs[1];
              D.45588 = iargs[1];
              D.45588->prev = 0B;
              D.45590 = D.45588->prev;
              D.45588->next = D.45590;
              D.45588 = iargs[1];
              D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.45508 = D.45507 & 274877906944;
              if (D.45508 != 0) goto <D.45679>; else goto <D.45680>;
              <D.45679>:
              iftmp.421 = 734;
              goto <D.45681>;
              <D.45680>:
              iftmp.421 = 363;
              <D.45681>:
              D.45588->opcode = iftmp.421;
              D.45588 = iargs[1];
              D.45588->flags = 0;
              D.45588 = iargs[1];
              D.45588->type = 0;
              D.45588 = iargs[1];
              D.45588->dreg = -1;
              D.45588 = iargs[1];
              D.45588 = iargs[1];
              D.45588 = iargs[1];
              D.45588->sreg3 = -1;
              D.45595 = D.45588->sreg3;
              D.45588->sreg2 = D.45595;
              D.45596 = D.45588->sreg2;
              D.45588->sreg1 = D.45596;
              D.45588 = iargs[1];
              D.45516 = cfg->ip;
              D.45588->cil_code = D.45516;
              D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.45508 = D.45507 & 274877906944;
              if (D.45508 != 0) goto <D.45682>; else goto <D.45683>;
              <D.45682>:
              {
                struct MonoInst * group;
                struct MonoInst * got_loc;

                got_loc = mono_get_got_var (cfg);
                D.45509 = cfg->mempool;
                group = mono_mempool_alloc (D.45509, 80);
                group->data.op[1].const_val = 0;
                D.45684 = group->data.op[1].const_val;
                group->data.op[0].const_val = D.45684;
                group->prev = 0B;
                D.45685 = group->prev;
                group->next = D.45685;
                group->opcode = 733;
                group->flags = 0;
                group->type = 0;
                group->dreg = -1;
                group->sreg3 = -1;
                D.45686 = group->sreg3;
                group->sreg2 = D.45686;
                D.45687 = group->sreg2;
                group->sreg1 = D.45687;
                D.45516 = cfg->ip;
                group->cil_code = D.45516;
                D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.45508 = D.45507 & 274877906944;
                if (D.45508 != 0) goto <D.45689>; else goto <D.45690>;
                <D.45689>:
                iftmp.422 = vtable->klass;
                goto <D.45691>;
                <D.45690>:
                iftmp.422 = vtable;
                <D.45691>:
                group->data.op[0].src = iftmp.422;
                group->data.op[1].src = 14B;
                D.45588 = iargs[1];
                D.45692 = got_loc->dreg;
                D.45588->sreg1 = D.45692;
                D.45588 = iargs[1];
                D.45588->data.op[1].p = group;
              }
              goto <D.45693>;
              <D.45683>:
              D.45588 = iargs[1];
              D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.45508 = D.45507 & 274877906944;
              if (D.45508 != 0) goto <D.45695>; else goto <D.45696>;
              <D.45695>:
              iftmp.423 = vtable->klass;
              goto <D.45697>;
              <D.45696>:
              iftmp.423 = vtable;
              <D.45697>:
              D.45588->data.op[0].p = iftmp.423;
              D.45588 = iargs[1];
              D.45588->data.op[1].src = 14B;
              <D.45693>:
              D.45588 = iargs[1];
              D.45588->type = 3;
              D.45588 = iargs[1];
              D.45698 = alloc_dreg (cfg, 3);
              D.45699 = (int) D.45698;
              D.45588->dreg = D.45699;
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              if (D.45541 != 0B) goto <D.45700>; else goto <D.45701>;
              <D.45700>:
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              D.45588 = iargs[1];
              D.45541->next = D.45588;
              D.45588 = iargs[1];
              D.45540 = cfg->cbb;
              D.45541 = D.45540->last_ins;
              D.45588->prev = D.45541;
              D.45540 = cfg->cbb;
              D.45588 = iargs[1];
              D.45540->last_ins = D.45588;
              goto <D.45702>;
              <D.45701>:
              D.45540 = cfg->cbb;
              D.45540 = cfg->cbb;
              D.45588 = iargs[1];
              D.45540->last_ins = D.45588;
              D.45541 = D.45540->last_ins;
              D.45540->code = D.45541;
              <D.45702>:
            }
            goto <D.45703>;
            <D.45663>:
            D.45509 = cfg->mempool;
            D.45704 = mono_mempool_alloc (D.45509, 80);
            iargs[0] = D.45704;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->data.op[1].const_val = 0;
            D.45559 = D.45558->data.op[1].const_val;
            D.45558->data.op[0].const_val = D.45559;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->prev = 0B;
            D.45560 = D.45558->prev;
            D.45558->next = D.45560;
            D.45558 = iargs[0];
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45706>; else goto <D.45707>;
            <D.45706>:
            iftmp.424 = 734;
            goto <D.45708>;
            <D.45707>:
            iftmp.424 = 363;
            <D.45708>:
            D.45558->opcode = iftmp.424;
            D.45558 = iargs[0];
            D.45558->flags = 0;
            D.45558 = iargs[0];
            D.45558->type = 0;
            D.45558 = iargs[0];
            D.45558->dreg = -1;
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558 = iargs[0];
            D.45558->sreg3 = -1;
            D.45561 = D.45558->sreg3;
            D.45558->sreg2 = D.45561;
            D.45562 = D.45558->sreg2;
            D.45558->sreg1 = D.45562;
            D.45558 = iargs[0];
            D.45516 = cfg->ip;
            D.45558->cil_code = D.45516;
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45709>; else goto <D.45710>;
            <D.45709>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.45509 = cfg->mempool;
              group = mono_mempool_alloc (D.45509, 80);
              group->data.op[1].const_val = 0;
              D.45711 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.45711;
              group->prev = 0B;
              D.45712 = group->prev;
              group->next = D.45712;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.45713 = group->sreg3;
              group->sreg2 = D.45713;
              D.45714 = group->sreg2;
              group->sreg1 = D.45714;
              D.45516 = cfg->ip;
              group->cil_code = D.45516;
              D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.45508 = D.45507 & 274877906944;
              if (D.45508 != 0) goto <D.45716>; else goto <D.45717>;
              <D.45716>:
              iftmp.425 = vtable->klass;
              goto <D.45718>;
              <D.45717>:
              iftmp.425 = vtable;
              <D.45718>:
              group->data.op[0].src = iftmp.425;
              group->data.op[1].src = 14B;
              D.45558 = iargs[0];
              D.45719 = got_loc->dreg;
              D.45558->sreg1 = D.45719;
              D.45558 = iargs[0];
              D.45558->data.op[1].p = group;
            }
            goto <D.45720>;
            <D.45710>:
            D.45558 = iargs[0];
            D.45507 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.45508 = D.45507 & 274877906944;
            if (D.45508 != 0) goto <D.45722>; else goto <D.45723>;
            <D.45722>:
            iftmp.426 = vtable->klass;
            goto <D.45724>;
            <D.45723>:
            iftmp.426 = vtable;
            <D.45724>:
            D.45558->data.op[0].p = iftmp.426;
            D.45558 = iargs[0];
            D.45558->data.op[1].src = 14B;
            <D.45720>:
            D.45558 = iargs[0];
            D.45558->type = 3;
            D.45558 = iargs[0];
            D.45725 = alloc_dreg (cfg, 3);
            D.45726 = (int) D.45725;
            D.45558->dreg = D.45726;
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            if (D.45541 != 0B) goto <D.45727>; else goto <D.45728>;
            <D.45727>:
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45558 = iargs[0];
            D.45541->next = D.45558;
            D.45558 = iargs[0];
            D.45540 = cfg->cbb;
            D.45541 = D.45540->last_ins;
            D.45558->prev = D.45541;
            D.45540 = cfg->cbb;
            D.45558 = iargs[0];
            D.45540->last_ins = D.45558;
            goto <D.45729>;
            <D.45728>:
            D.45540 = cfg->cbb;
            D.45540 = cfg->cbb;
            D.45558 = iargs[0];
            D.45540->last_ins = D.45558;
            D.45541 = D.45540->last_ins;
            D.45540->code = D.45541;
            <D.45729>:
            <D.45703>:
          }
        finally
          {
            pass_lw = {CLOBBER};
          }
      }
      <D.45610>:
      D.45550 = mono_emit_jit_icall (cfg, alloc_ftn, &iargs);
      return D.45550;
    }
  finally
    {
      iargs = {CLOBBER};
    }
}


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

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


mono_method_check_inlining (struct MonoCompile * cfg, struct MonoMethod * method)
{
  struct MonoGenericSharingContext * D.45737;
  gboolean D.45740;
  unsigned int D.45741;
  int D.45744;
  short unsigned int D.45749;
  unsigned int D.45750;
  unsigned int D.45751;
  struct MonoClass * D.45753;
  long unsigned int D.45754;
  long unsigned int D.45755;
  int D.45757;
  int inline_limit_inited.427;
  const gchar * D.45761;
  const gchar * D.45764;
  int inline_limit.428;
  unsigned int D.45767;
  int inline_limit.429;
  unsigned int inline_limit.430;
  int D.45772;
  int D.45773;
  unsigned int D.45776;
  unsigned int D.45777;
  struct MonoDomain * D.45782;
  long unsigned int D.45785;
  long unsigned int D.45786;
  int D.45789;
  unsigned int D.45793;
  unsigned int D.45794;
  long unsigned int D.45797;
  long unsigned int D.45800;
  struct MonoClassRuntimeInfo * D.45803;
  long unsigned int D.45808;
  long unsigned int D.45809;
  int D.45813;
  int D.45823;
  unsigned char D.45828;
  struct MonoMethodHeaderSummary header;
  struct MonoVTable * vtable;

  try
    {
      D.45737 = cfg->generic_sharing_context;
      if (D.45737 != 0B) goto <D.45738>; else goto <D.45739>;
      <D.45738>:
      D.45740 = 0;
      return D.45740;
      <D.45739>:
      D.45741 = cfg->inline_depth;
      if (D.45741 > 10) goto <D.45742>; else goto <D.45743>;
      <D.45742>:
      D.45740 = 0;
      return D.45740;
      <D.45743>:
      D.45744 = mono_method_get_header_summary (method, &header);
      if (D.45744 == 0) goto <D.45745>; else goto <D.45746>;
      <D.45745>:
      D.45740 = 0;
      return D.45740;
      <D.45746>:
      D.45749 = method->iflags;
      D.45750 = (unsigned int) D.45749;
      D.45751 = D.45750 & 40;
      if (D.45751 != 0) goto <D.45747>; else goto <D.45752>;
      <D.45752>:
      D.45753 = method->klass;
      D.45754 = BIT_FIELD_REF <*D.45753, 64, 256>;
      D.45755 = D.45754 & 4194304;
      if (D.45755 != 0) goto <D.45747>; else goto <D.45756>;
      <D.45756>:
      D.45757 = header.has_clauses;
      if (D.45757 != 0) goto <D.45747>; else goto <D.45748>;
      <D.45747>:
      D.45740 = 0;
      return D.45740;
      <D.45748>:
      inline_limit_inited.427 = inline_limit_inited;
      if (inline_limit_inited.427 == 0) goto <D.45759>; else goto <D.45760>;
      <D.45759>:
      D.45761 = monoeg_g_getenv ("MONO_INLINELIMIT");
      if (D.45761 != 0B) goto <D.45762>; else goto <D.45763>;
      <D.45762>:
      D.45764 = monoeg_g_getenv ("MONO_INLINELIMIT");
      inline_limit.428 = atoi (D.45764);
      inline_limit = inline_limit.428;
      goto <D.45766>;
      <D.45763>:
      inline_limit = 20;
      <D.45766>:
      inline_limit_inited = 1;
      <D.45760>:
      D.45767 = header.code_size;
      inline_limit.429 = inline_limit;
      inline_limit.430 = (unsigned int) inline_limit.429;
      if (D.45767 >= inline_limit.430) goto <D.45770>; else goto <D.45771>;
      <D.45770>:
      D.45749 = method->iflags;
      D.45772 = (int) D.45749;
      D.45773 = D.45772 & 256;
      if (D.45773 == 0) goto <D.45774>; else goto <D.45775>;
      <D.45774>:
      D.45740 = 0;
      return D.45740;
      <D.45775>:
      <D.45771>:
      D.45776 = cfg->opt;
      D.45777 = D.45776 & 512;
      if (D.45777 == 0) goto <D.45778>; else goto <D.45779>;
      <D.45778>:
      D.45749 = method->iflags;
      D.45772 = (int) D.45749;
      D.45773 = D.45772 & 256;
      if (D.45773 != 0) goto <D.45780>; else goto <D.45781>;
      <D.45780>:
      D.45782 = cfg->domain;
      D.45753 = method->klass;
      vtable = mono_class_vtable (D.45782, D.45753);
      if (vtable == 0B) goto <D.45783>; else goto <D.45784>;
      <D.45783>:
      D.45740 = 0;
      return D.45740;
      <D.45784>:
      D.45785 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45786 = D.45785 & 274877906944;
      if (D.45786 != 0) goto <D.45787>; else goto <D.45788>;
      <D.45787>:
      D.45753 = method->klass;
      D.45789 = mono_class_needs_cctor_run (D.45753, 0B);
      if (D.45789 != 0) goto <D.45790>; else goto <D.45791>;
      <D.45790>:
      D.45740 = 0;
      return D.45740;
      <D.45791>:
      <D.45788>:
      mono_runtime_class_init (vtable);
      goto <D.45792>;
      <D.45781>:
      D.45753 = method->klass;
      D.45793 = D.45753->flags;
      D.45794 = D.45793 & 1048576;
      if (D.45794 != 0) goto <D.45795>; else goto <D.45796>;
      <D.45795>:
      D.45785 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45797 = D.45785 & 68719476736;
      if (D.45797 != 0) goto <D.45798>; else goto <D.45799>;
      <D.45798>:
      D.45753 = method->klass;
      D.45754 = BIT_FIELD_REF <*D.45753, 64, 256>;
      D.45800 = D.45754 & 67108864;
      if (D.45800 != 0) goto <D.45801>; else goto <D.45802>;
      <D.45801>:
      D.45753 = method->klass;
      D.45803 = D.45753->runtime_info;
      if (D.45803 == 0B) goto <D.45804>; else goto <D.45805>;
      <D.45804>:
      D.45740 = 0;
      return D.45740;
      <D.45805>:
      D.45782 = cfg->domain;
      D.45753 = method->klass;
      vtable = mono_class_vtable (D.45782, D.45753);
      if (vtable == 0B) goto <D.45806>; else goto <D.45807>;
      <D.45806>:
      D.45740 = 0;
      return D.45740;
      <D.45807>:
      D.45808 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.45809 = D.45808 & 33554432;
      if (D.45809 == 0) goto <D.45810>; else goto <D.45811>;
      <D.45810>:
      D.45740 = 0;
      return D.45740;
      <D.45811>:
      mono_runtime_class_init (vtable);
      <D.45802>:
      <D.45799>:
      goto <D.45812>;
      <D.45796>:
      D.45753 = method->klass;
      D.45813 = mono_class_needs_cctor_run (D.45753, 0B);
      if (D.45813 != 0) goto <D.45814>; else goto <D.45815>;
      <D.45814>:
      D.45753 = method->klass;
      D.45803 = D.45753->runtime_info;
      if (D.45803 == 0B) goto <D.45816>; else goto <D.45817>;
      <D.45816>:
      D.45740 = 0;
      return D.45740;
      <D.45817>:
      D.45782 = cfg->domain;
      D.45753 = method->klass;
      vtable = mono_class_vtable (D.45782, D.45753);
      if (vtable == 0B) goto <D.45818>; else goto <D.45819>;
      <D.45818>:
      D.45740 = 0;
      return D.45740;
      <D.45819>:
      D.45808 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.45809 = D.45808 & 33554432;
      if (D.45809 == 0) goto <D.45820>; else goto <D.45821>;
      <D.45820>:
      D.45740 = 0;
      return D.45740;
      <D.45821>:
      <D.45815>:
      <D.45812>:
      <D.45792>:
      goto <D.45822>;
      <D.45779>:
      D.45753 = method->klass;
      D.45823 = mono_class_needs_cctor_run (D.45753, 0B);
      if (D.45823 != 0) goto <D.45824>; else goto <D.45825>;
      <D.45824>:
      D.45753 = method->klass;
      D.45793 = D.45753->flags;
      D.45794 = D.45793 & 1048576;
      if (D.45794 == 0) goto <D.45826>; else goto <D.45827>;
      <D.45826>:
      D.45740 = 0;
      return D.45740;
      <D.45827>:
      <D.45825>:
      <D.45822>:
      D.45828 = mono_method_has_declsec (method);
      if (D.45828 != 0) goto <D.45829>; else goto <D.45830>;
      <D.45829>:
      D.45740 = 0;
      return D.45740;
      <D.45830>:
      D.45740 = 1;
      return D.45740;
    }
  finally
    {
      header = {CLOBBER};
    }
}


atoi (const char * __nptr)
{
  int D.45833;
  long int D.45834;

  D.45834 = strtol (__nptr, 0B, 10);
  D.45833 = (int) D.45834;
  return D.45833;
}


emit_get_rgctx_gsharedvt_call (struct MonoCompile * cfg, int context_used, struct MonoMethodSignature * sig, struct MonoMethod * cmethod, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.45836;
  struct MonoMethod * D.45837;
  int D.45838;
  struct MonoInst * D.45839;
  struct MonoJumpInfoGSharedVtCall * call_info;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.45836 = cfg->mempool;
  call_info = mono_mempool_alloc0 (D.45836, 16);
  call_info->sig = sig;
  call_info->method = cmethod;
  D.45836 = cfg->mempool;
  D.45837 = cfg->current_method;
  D.45838 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.45836, D.45837, D.45838, 45, call_info, rgctx_type);
  D.45837 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.45837, context_used);
  D.45839 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.45839;
}


save_cast_details (struct MonoCompile * cfg, struct MonoClass * klass, int obj_reg, gboolean null_check, struct MonoBasicBlock * * out_bblock)
{
  struct MonoDebugOptions * D.45841;
  int D.45842;
  unsigned int D.45845;
  unsigned int D.45846;
  unsigned int D.45847;
  struct MonoMemPool * D.45850;
  unsigned int D.45851;
  unsigned int D.45852;
  unsigned int D.45853;
  int D.45854;
  long int D.45855;
  struct MonoInst * D.45856;
  int D.45857;
  int D.45858;
  const unsigned char * D.45859;
  struct MonoBasicBlock * D.45860;
  struct MonoInst * D.45861;
  long int D.45865;
  struct MonoInst * D.45866;
  int D.45867;
  int D.45868;
  unsigned int D.45871;
  unsigned int D.45872;
  int D.45873;
  unsigned char * D.45877;
  struct MonoBasicBlock * * D.45880;
  long int D.45881;
  unsigned char * D.45882;
  long int D.45883;
  long int D.45884;
  long unsigned int D.45885;
  long unsigned int D.45886;
  struct MonoBasicBlock * * D.45887;
  unsigned int D.45888;
  short unsigned int D.45893;
  short unsigned int D.45894;
  short unsigned int D.45896;
  short unsigned int D.45898;
  struct MonoBasicBlock * * D.45899;
  struct MonoBasicBlock * * D.45900;
  struct MonoBasicBlock * D.45901;
  void * D.45911;
  struct MonoBasicBlock * * D.45912;
  struct MonoBasicBlock * * D.45913;
  long unsigned int D.45917;
  long unsigned int D.45918;
  unsigned int D.45921;
  unsigned int D.45922;
  int D.45923;
  struct _IO_FILE * stderr.431;
  long int D.45947;
  struct MonoInst * D.45948;
  int D.45949;
  int D.45950;
  long int D.45954;
  struct MonoInst * D.45955;
  int D.45956;
  int D.45957;
  long int D.45961;
  struct MonoInst * D.45962;
  int D.45963;
  int D.45964;
  int D.45965;
  long int D.45969;
  struct MonoInst * D.45970;
  int D.45971;
  int D.45972;
  long int D.45976;
  struct MonoInst * D.45977;
  int D.45978;
  int D.45979;
  unsigned char * D.45985;
  long int D.45988;
  long int D.45989;
  long unsigned int D.45990;
  long unsigned int D.45991;
  struct MonoBasicBlock * * D.45992;

  D.45841 = mini_get_debug_options ();
  D.45842 = D.45841->better_cast_details;
  if (D.45842 != 0) goto <D.45843>; else goto <D.45844>;
  <D.45843>:
  {
    int to_klass_reg;
    int vtable_reg;
    int klass_reg;
    struct MonoBasicBlock * is_null_bb;
    struct MonoInst * tls_get;

    D.45845 = alloc_preg (cfg);
    to_klass_reg = (int) D.45845;
    D.45846 = alloc_preg (cfg);
    vtable_reg = (int) D.45846;
    D.45847 = alloc_preg (cfg);
    klass_reg = (int) D.45847;
    is_null_bb = 0B;
    if (null_check != 0) goto <D.45848>; else goto <D.45849>;
    <D.45848>:
    D.45850 = cfg->mempool;
    is_null_bb = mono_mempool_alloc0 (D.45850, 296);
    D.45851 = cfg->num_bblocks;
    D.45852 = D.45851;
    D.45853 = D.45852 + 1;
    cfg->num_bblocks = D.45853;
    D.45854 = (int) D.45852;
    is_null_bb->block_num = D.45854;
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45855 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45855;
      inst->prev = 0B;
      D.45856 = inst->prev;
      inst->next = D.45856;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45857 = inst->sreg3;
      inst->sreg2 = D.45857;
      D.45858 = inst->sreg2;
      inst->sreg1 = D.45858;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->dreg = -1;
      inst->sreg1 = obj_reg;
      inst->data.op[1].const_val = 0;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45862>; else goto <D.45863>;
      <D.45862>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45864>;
      <D.45863>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45864>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.45850 = cfg->mempool;
      ins = mono_mempool_alloc (D.45850, 80);
      ins->data.op[1].const_val = 0;
      D.45865 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.45865;
      ins->prev = 0B;
      D.45866 = ins->prev;
      ins->next = D.45866;
      ins->opcode = 551;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.45867 = ins->sreg3;
      ins->sreg2 = D.45867;
      D.45868 = ins->sreg2;
      ins->sreg1 = D.45868;
      D.45859 = cfg->ip;
      ins->cil_code = D.45859;
      if (0 != 0) goto <D.45869>; else goto <D.45870>;
      <D.45869>:
      D.45850 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.45850, 296);
      D.45851 = cfg->num_bblocks;
      D.45871 = D.45851;
      D.45872 = D.45871 + 1;
      cfg->num_bblocks = D.45872;
      D.45873 = (int) D.45871;
      falsebb->block_num = D.45873;
      ins->data.op[0].target_block = is_null_bb;
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, is_null_bb);
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45874>; else goto <D.45875>;
      <D.45874>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = ins;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      ins->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = ins;
      goto <D.45876>;
      <D.45875>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = ins;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45876>:
      D.45877 = falsebb->cil_code;
      if (D.45877 != 0B) goto <D.45878>; else goto <D.45879>;
      <D.45878>:
      D.45880 = cfg->cil_offset_to_bb;
      D.45877 = falsebb->cil_code;
      D.45881 = (long int) D.45877;
      D.45882 = cfg->cil_start;
      D.45883 = (long int) D.45882;
      D.45884 = D.45881 - D.45883;
      D.45885 = (long unsigned int) D.45884;
      D.45886 = D.45885 * 8;
      D.45887 = D.45880 + D.45886;
      *D.45887 = falsebb;
      <D.45879>:
      D.45888 = cfg->real_offset;
      falsebb->real_offset = D.45888;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45892>; else goto <D.45889>;
      <D.45892>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45894 = D.45893 + 64985;
      if (D.45894 <= 9) goto <D.45890>; else goto <D.45895>;
      <D.45895>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45896 = D.45893 + 64878;
      if (D.45896 <= 9) goto <D.45890>; else goto <D.45897>;
      <D.45897>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45898 = D.45893 + 64888;
      if (D.45898 <= 9) goto <D.45890>; else goto <D.45889>;
      <D.45890>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45899 = D.45861->data.op[1].many_blocks;
      D.45900 = D.45899 + 8;
      D.45901 = *D.45900;
      if (D.45901 == 0B) goto <D.45902>; else goto <D.45889>;
      <D.45902>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45899 = D.45861->data.op[1].many_blocks;
      D.45900 = D.45899 + 8;
      *D.45900 = falsebb;
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, falsebb);
      goto <D.45891>;
      <D.45889>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 == 0B) goto <D.45903>; else goto <D.45905>;
      <D.45905>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      if (D.45893 != 442) goto <D.45906>; else goto <D.45904>;
      <D.45906>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      if (D.45893 != 759) goto <D.45907>; else goto <D.45904>;
      <D.45907>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45894 = D.45893 + 64985;
      if (D.45894 > 9) goto <D.45908>; else goto <D.45904>;
      <D.45908>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45896 = D.45893 + 64878;
      if (D.45896 > 9) goto <D.45909>; else goto <D.45904>;
      <D.45909>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45898 = D.45893 + 64888;
      if (D.45898 > 9) goto <D.45903>; else goto <D.45904>;
      <D.45903>:
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, falsebb);
      <D.45904>:
      <D.45891>:
      D.45860 = cfg->cbb;
      D.45860->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.45910>;
      <D.45870>:
      D.45850 = cfg->mempool;
      D.45911 = mono_mempool_alloc (D.45850, 16);
      ins->data.op[1].many_blocks = D.45911;
      D.45912 = ins->data.op[1].many_blocks;
      *D.45912 = is_null_bb;
      D.45912 = ins->data.op[1].many_blocks;
      D.45913 = D.45912 + 8;
      *D.45913 = 0B;
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, is_null_bb);
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45914>; else goto <D.45915>;
      <D.45914>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = ins;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      ins->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = ins;
      goto <D.45916>;
      <D.45915>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = ins;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45916>:
      D.45917 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45918 = D.45917 & 34359738368;
      if (D.45918 == 0) goto <D.45919>; else goto <D.45920>;
      <D.45919>:
      D.45850 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.45850, 296);
      D.45851 = cfg->num_bblocks;
      D.45921 = D.45851;
      D.45922 = D.45921 + 1;
      cfg->num_bblocks = D.45922;
      D.45923 = (int) D.45921;
      falsebb->block_num = D.45923;
      D.45912 = ins->data.op[1].many_blocks;
      D.45913 = D.45912 + 8;
      *D.45913 = falsebb;
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, falsebb);
      D.45877 = falsebb->cil_code;
      if (D.45877 != 0B) goto <D.45924>; else goto <D.45925>;
      <D.45924>:
      D.45880 = cfg->cil_offset_to_bb;
      D.45877 = falsebb->cil_code;
      D.45881 = (long int) D.45877;
      D.45882 = cfg->cil_start;
      D.45883 = (long int) D.45882;
      D.45884 = D.45881 - D.45883;
      D.45885 = (long unsigned int) D.45884;
      D.45886 = D.45885 * 8;
      D.45887 = D.45880 + D.45886;
      *D.45887 = falsebb;
      <D.45925>:
      D.45888 = cfg->real_offset;
      falsebb->real_offset = D.45888;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45929>; else goto <D.45926>;
      <D.45929>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45894 = D.45893 + 64985;
      if (D.45894 <= 9) goto <D.45927>; else goto <D.45930>;
      <D.45930>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45896 = D.45893 + 64878;
      if (D.45896 <= 9) goto <D.45927>; else goto <D.45931>;
      <D.45931>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45898 = D.45893 + 64888;
      if (D.45898 <= 9) goto <D.45927>; else goto <D.45926>;
      <D.45927>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45899 = D.45861->data.op[1].many_blocks;
      D.45900 = D.45899 + 8;
      D.45901 = *D.45900;
      if (D.45901 == 0B) goto <D.45932>; else goto <D.45926>;
      <D.45932>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45899 = D.45861->data.op[1].many_blocks;
      D.45900 = D.45899 + 8;
      *D.45900 = falsebb;
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, falsebb);
      goto <D.45928>;
      <D.45926>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 == 0B) goto <D.45933>; else goto <D.45935>;
      <D.45935>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      if (D.45893 != 442) goto <D.45936>; else goto <D.45934>;
      <D.45936>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      if (D.45893 != 759) goto <D.45937>; else goto <D.45934>;
      <D.45937>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45894 = D.45893 + 64985;
      if (D.45894 > 9) goto <D.45938>; else goto <D.45934>;
      <D.45938>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45896 = D.45893 + 64878;
      if (D.45896 > 9) goto <D.45939>; else goto <D.45934>;
      <D.45939>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45893 = D.45861->opcode;
      D.45898 = D.45893 + 64888;
      if (D.45898 > 9) goto <D.45933>; else goto <D.45934>;
      <D.45933>:
      D.45860 = cfg->cbb;
      mono_link_bblock (cfg, D.45860, falsebb);
      <D.45934>:
      <D.45928>:
      D.45860 = cfg->cbb;
      D.45860->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.45940>;
      <D.45920>:
      D.45860 = cfg->cbb;
      D.45860->extended = 1;
      <D.45940>:
      <D.45910>:
    }
    <D.45849>:
    tls_get = mono_get_jit_tls_intrinsic (cfg);
    if (tls_get == 0B) goto <D.45941>; else goto <D.45942>;
    <D.45941>:
    stderr.431 = stderr;
    fprintf (stderr.431, "error: --debug=casts not supported on this platform.\n.");
    exit (1);
    <D.45942>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    if (D.45861 != 0B) goto <D.45944>; else goto <D.45945>;
    <D.45944>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45861->next = tls_get;
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    tls_get->prev = D.45861;
    D.45860 = cfg->cbb;
    D.45860->last_ins = tls_get;
    goto <D.45946>;
    <D.45945>:
    D.45860 = cfg->cbb;
    D.45860 = cfg->cbb;
    D.45860->last_ins = tls_get;
    D.45861 = D.45860->last_ins;
    D.45860->code = D.45861;
    <D.45946>:
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45947 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45947;
      inst->prev = 0B;
      D.45948 = inst->prev;
      inst->next = D.45948;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45949 = inst->sreg3;
      inst->sreg2 = D.45949;
      D.45950 = inst->sreg2;
      inst->sreg1 = D.45950;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->dreg = vtable_reg;
      inst->sreg1 = obj_reg;
      inst->data.op[0].const_val = 0;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45951>; else goto <D.45952>;
      <D.45951>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45953>;
      <D.45952>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45953>:
    }
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45954 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45954;
      inst->prev = 0B;
      D.45955 = inst->prev;
      inst->next = D.45955;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45956 = inst->sreg3;
      inst->sreg2 = D.45956;
      D.45957 = inst->sreg2;
      inst->sreg1 = D.45957;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45958>; else goto <D.45959>;
      <D.45958>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45960>;
      <D.45959>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45960>:
    }
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45961 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45961;
      inst->prev = 0B;
      D.45962 = inst->prev;
      inst->next = D.45962;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45963 = inst->sreg3;
      inst->sreg2 = D.45963;
      D.45964 = inst->sreg2;
      inst->sreg1 = D.45964;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->sreg1 = klass_reg;
      D.45965 = tls_get->dreg;
      inst->dreg = D.45965;
      inst->data.op[0].const_val = 88;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45966>; else goto <D.45967>;
      <D.45966>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45968>;
      <D.45967>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45968>:
    }
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45969 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45969;
      inst->prev = 0B;
      D.45970 = inst->prev;
      inst->next = D.45970;
      inst->opcode = 363;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45971 = inst->sreg3;
      inst->sreg2 = D.45971;
      D.45972 = inst->sreg2;
      inst->sreg1 = D.45972;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->dreg = to_klass_reg;
      inst->data.op[0].p = klass;
      inst->type = 3;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45973>; else goto <D.45974>;
      <D.45973>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45975>;
      <D.45974>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45975>:
    }
    {
      struct MonoInst * inst;

      D.45850 = cfg->mempool;
      inst = mono_mempool_alloc (D.45850, 80);
      inst->data.op[1].const_val = 0;
      D.45976 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45976;
      inst->prev = 0B;
      D.45977 = inst->prev;
      inst->next = D.45977;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45978 = inst->sreg3;
      inst->sreg2 = D.45978;
      D.45979 = inst->sreg2;
      inst->sreg1 = D.45979;
      D.45859 = cfg->ip;
      inst->cil_code = D.45859;
      inst->sreg1 = to_klass_reg;
      D.45965 = tls_get->dreg;
      inst->dreg = D.45965;
      inst->data.op[0].const_val = 96;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      if (D.45861 != 0B) goto <D.45980>; else goto <D.45981>;
      <D.45980>:
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      D.45861->next = inst;
      D.45860 = cfg->cbb;
      D.45861 = D.45860->last_ins;
      inst->prev = D.45861;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      goto <D.45982>;
      <D.45981>:
      D.45860 = cfg->cbb;
      D.45860 = cfg->cbb;
      D.45860->last_ins = inst;
      D.45861 = D.45860->last_ins;
      D.45860->code = D.45861;
      <D.45982>:
    }
    if (null_check != 0) goto <D.45983>; else goto <D.45984>;
    <D.45983>:
    D.45985 = is_null_bb->cil_code;
    if (D.45985 != 0B) goto <D.45986>; else goto <D.45987>;
    <D.45986>:
    D.45880 = cfg->cil_offset_to_bb;
    D.45985 = is_null_bb->cil_code;
    D.45988 = (long int) D.45985;
    D.45882 = cfg->cil_start;
    D.45883 = (long int) D.45882;
    D.45989 = D.45988 - D.45883;
    D.45990 = (long unsigned int) D.45989;
    D.45991 = D.45990 * 8;
    D.45992 = D.45880 + D.45991;
    *D.45992 = is_null_bb;
    <D.45987>:
    D.45888 = cfg->real_offset;
    is_null_bb->real_offset = D.45888;
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    if (D.45861 != 0B) goto <D.45996>; else goto <D.45993>;
    <D.45996>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45894 = D.45893 + 64985;
    if (D.45894 <= 9) goto <D.45994>; else goto <D.45997>;
    <D.45997>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45896 = D.45893 + 64878;
    if (D.45896 <= 9) goto <D.45994>; else goto <D.45998>;
    <D.45998>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45898 = D.45893 + 64888;
    if (D.45898 <= 9) goto <D.45994>; else goto <D.45993>;
    <D.45994>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45899 = D.45861->data.op[1].many_blocks;
    D.45900 = D.45899 + 8;
    D.45901 = *D.45900;
    if (D.45901 == 0B) goto <D.45999>; else goto <D.45993>;
    <D.45999>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45899 = D.45861->data.op[1].many_blocks;
    D.45900 = D.45899 + 8;
    *D.45900 = is_null_bb;
    D.45860 = cfg->cbb;
    mono_link_bblock (cfg, D.45860, is_null_bb);
    goto <D.45995>;
    <D.45993>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    if (D.45861 == 0B) goto <D.46000>; else goto <D.46002>;
    <D.46002>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    if (D.45893 != 442) goto <D.46003>; else goto <D.46001>;
    <D.46003>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    if (D.45893 != 759) goto <D.46004>; else goto <D.46001>;
    <D.46004>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45894 = D.45893 + 64985;
    if (D.45894 > 9) goto <D.46005>; else goto <D.46001>;
    <D.46005>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45896 = D.45893 + 64878;
    if (D.45896 > 9) goto <D.46006>; else goto <D.46001>;
    <D.46006>:
    D.45860 = cfg->cbb;
    D.45861 = D.45860->last_ins;
    D.45893 = D.45861->opcode;
    D.45898 = D.45893 + 64888;
    if (D.45898 > 9) goto <D.46000>; else goto <D.46001>;
    <D.46000>:
    D.45860 = cfg->cbb;
    mono_link_bblock (cfg, D.45860, is_null_bb);
    <D.46001>:
    <D.45995>:
    D.45860 = cfg->cbb;
    D.45860->next_bb = is_null_bb;
    cfg->cbb = is_null_bb;
    if (out_bblock != 0B) goto <D.46007>; else goto <D.46008>;
    <D.46007>:
    D.45860 = cfg->cbb;
    *out_bblock = D.45860;
    <D.46008>:
    <D.45984>:
  }
  <D.45844>:
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.46009;

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


reset_cast_details (struct MonoCompile * cfg)
{
  struct MonoDebugOptions * D.46011;
  int D.46012;
  struct MonoBasicBlock * D.46015;
  struct MonoInst * D.46016;
  struct MonoMemPool * D.46020;
  long int D.46021;
  struct MonoInst * D.46022;
  int D.46023;
  int D.46024;
  const unsigned char * D.46025;
  int D.46026;

  D.46011 = mini_get_debug_options ();
  D.46012 = D.46011->better_cast_details;
  if (D.46012 != 0) goto <D.46013>; else goto <D.46014>;
  <D.46013>:
  {
    struct MonoInst * tls_get;

    tls_get = mono_get_jit_tls_intrinsic (cfg);
    D.46015 = cfg->cbb;
    D.46016 = D.46015->last_ins;
    if (D.46016 != 0B) goto <D.46017>; else goto <D.46018>;
    <D.46017>:
    D.46015 = cfg->cbb;
    D.46016 = D.46015->last_ins;
    D.46016->next = tls_get;
    D.46015 = cfg->cbb;
    D.46016 = D.46015->last_ins;
    tls_get->prev = D.46016;
    D.46015 = cfg->cbb;
    D.46015->last_ins = tls_get;
    goto <D.46019>;
    <D.46018>:
    D.46015 = cfg->cbb;
    D.46015 = cfg->cbb;
    D.46015->last_ins = tls_get;
    D.46016 = D.46015->last_ins;
    D.46015->code = D.46016;
    <D.46019>:
    {
      struct MonoInst * inst;

      D.46020 = cfg->mempool;
      inst = mono_mempool_alloc (D.46020, 80);
      inst->data.op[1].const_val = 0;
      D.46021 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46021;
      inst->prev = 0B;
      D.46022 = inst->prev;
      inst->next = D.46022;
      inst->opcode = 381;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46023 = inst->sreg3;
      inst->sreg2 = D.46023;
      D.46024 = inst->sreg2;
      inst->sreg1 = D.46024;
      D.46025 = cfg->ip;
      inst->cil_code = D.46025;
      D.46026 = tls_get->dreg;
      inst->dreg = D.46026;
      inst->data.op[0].const_val = 88;
      inst->data.op[1].const_val = 0;
      D.46015 = cfg->cbb;
      D.46016 = D.46015->last_ins;
      if (D.46016 != 0B) goto <D.46027>; else goto <D.46028>;
      <D.46027>:
      D.46015 = cfg->cbb;
      D.46016 = D.46015->last_ins;
      D.46016->next = inst;
      D.46015 = cfg->cbb;
      D.46016 = D.46015->last_ins;
      inst->prev = D.46016;
      D.46015 = cfg->cbb;
      D.46015->last_ins = inst;
      goto <D.46029>;
      <D.46028>:
      D.46015 = cfg->cbb;
      D.46015 = cfg->cbb;
      D.46015->last_ins = inst;
      D.46016 = D.46015->last_ins;
      D.46015->code = D.46016;
      <D.46029>:
    }
  }
  <D.46014>:
}


handle_isinst (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src, int context_used)
{
  unsigned int D.46030;
  unsigned int D.46031;
  struct MonoMemPool * D.46036;
  void * D.46037;
  struct MonoInst * D.46038;
  long int D.46039;
  struct MonoInst * D.46040;
  int D.46041;
  int D.46042;
  const unsigned char * D.46043;
  unsigned int D.46044;
  int D.46045;
  int D.46046;
  struct MonoBasicBlock * D.46047;
  struct MonoInst * D.46048;
  struct MonoInst * D.46052;
  unsigned int D.46053;
  unsigned int D.46054;
  unsigned int D.46055;
  int D.46056;
  unsigned int D.46057;
  unsigned int D.46058;
  int D.46059;
  unsigned int D.46060;
  unsigned int D.46061;
  int D.46062;
  long int D.46063;
  struct MonoInst * D.46064;
  int D.46065;
  int D.46066;
  long int D.46070;
  struct MonoInst * D.46071;
  int D.46072;
  int D.46073;
  long int D.46077;
  struct MonoInst * D.46078;
  int D.46079;
  int D.46080;
  unsigned int D.46083;
  unsigned int D.46084;
  int D.46085;
  unsigned char * D.46089;
  struct MonoBasicBlock * * D.46092;
  long int D.46093;
  unsigned char * D.46094;
  long int D.46095;
  long int D.46096;
  long unsigned int D.46097;
  long unsigned int D.46098;
  struct MonoBasicBlock * * D.46099;
  unsigned int D.46100;
  short unsigned int D.46105;
  short unsigned int D.46106;
  short unsigned int D.46108;
  short unsigned int D.46110;
  struct MonoBasicBlock * * D.46111;
  struct MonoBasicBlock * * D.46112;
  struct MonoBasicBlock * D.46113;
  void * D.46123;
  struct MonoBasicBlock * * D.46124;
  struct MonoBasicBlock * * D.46125;
  long unsigned int D.46129;
  long unsigned int D.46130;
  unsigned int D.46133;
  unsigned int D.46134;
  int D.46135;
  long int D.46153;
  struct MonoInst * D.46154;
  int D.46155;
  int D.46156;
  unsigned int D.46160;
  unsigned int D.46161;
  _Bool D.46164;
  long int D.46165;
  long int D.46166;
  unsigned int D.46170;
  unsigned char D.46171;
  unsigned int D.46174;
  unsigned int D.46175;
  long int D.46178;
  struct MonoInst * D.46179;
  int D.46180;
  int D.46181;
  long int D.46185;
  struct MonoInst * D.46186;
  int D.46187;
  int D.46188;
  long int D.46189;
  long int D.46193;
  struct MonoInst * D.46194;
  int D.46195;
  int D.46196;
  unsigned int D.46199;
  unsigned int D.46200;
  int D.46201;
  unsigned char * D.46205;
  long int D.46208;
  long int D.46209;
  long unsigned int D.46210;
  long unsigned int D.46211;
  struct MonoBasicBlock * * D.46212;
  void * D.46228;
  struct MonoBasicBlock * * D.46229;
  struct MonoBasicBlock * * D.46230;
  unsigned int D.46236;
  unsigned int D.46237;
  int D.46238;
  long int D.46256;
  struct MonoInst * D.46257;
  int D.46258;
  int D.46259;
  long int D.46263;
  struct MonoInst * D.46264;
  int D.46265;
  int D.46266;
  struct MonoClass * D.46270;
  struct MonoClass * D.46271;
  unsigned int D.46274;
  long int D.46275;
  struct MonoInst * D.46276;
  int D.46277;
  int D.46278;
  struct MonoClass * D.46282;
  struct MonoClass * D.46283;
  long int D.46284;
  struct MonoInst * D.46285;
  int D.46286;
  int D.46287;
  unsigned int D.46290;
  unsigned int D.46291;
  int D.46292;
  unsigned char * D.46296;
  long int D.46299;
  long int D.46300;
  long unsigned int D.46301;
  long unsigned int D.46302;
  struct MonoBasicBlock * * D.46303;
  void * D.46319;
  struct MonoBasicBlock * * D.46320;
  struct MonoBasicBlock * * D.46321;
  unsigned int D.46327;
  unsigned int D.46328;
  int D.46329;
  long int D.46350;
  struct MonoInst * D.46351;
  int D.46352;
  int D.46353;
  unsigned int D.46356;
  unsigned int D.46357;
  int D.46358;
  unsigned char * D.46362;
  long int D.46365;
  long int D.46366;
  long unsigned int D.46367;
  long unsigned int D.46368;
  struct MonoBasicBlock * * D.46369;
  void * D.46385;
  struct MonoBasicBlock * * D.46386;
  struct MonoBasicBlock * * D.46387;
  unsigned int D.46393;
  unsigned int D.46394;
  int D.46395;
  long int D.46416;
  struct MonoInst * D.46417;
  int D.46418;
  int D.46419;
  unsigned int D.46422;
  unsigned int D.46423;
  int D.46424;
  unsigned char * D.46428;
  long int D.46431;
  long int D.46432;
  long unsigned int D.46433;
  long unsigned int D.46434;
  struct MonoBasicBlock * * D.46435;
  void * D.46451;
  struct MonoBasicBlock * * D.46452;
  struct MonoBasicBlock * * D.46453;
  unsigned int D.46459;
  unsigned int D.46460;
  int D.46461;
  unsigned int D.46480;
  unsigned int D.46481;
  unsigned char D.46487;
  unsigned int D.46490;
  long int D.46491;
  struct MonoInst * D.46492;
  int D.46493;
  int D.46494;
  long int D.46498;
  struct MonoInst * D.46499;
  int D.46500;
  int D.46501;
  long int D.46505;
  struct MonoInst * D.46506;
  int D.46507;
  int D.46508;
  unsigned int D.46511;
  unsigned int D.46512;
  int D.46513;
  unsigned char * D.46517;
  long int D.46520;
  long int D.46521;
  long unsigned int D.46522;
  long unsigned int D.46523;
  struct MonoBasicBlock * * D.46524;
  void * D.46540;
  struct MonoBasicBlock * * D.46541;
  struct MonoBasicBlock * * D.46542;
  unsigned int D.46548;
  unsigned int D.46549;
  int D.46550;
  int D.46569;
  long int D.46574;
  struct MonoInst * D.46575;
  int D.46576;
  int D.46577;
  long unsigned int D.46584;
  unsigned int D.46586;
  unsigned int D.46587;
  unsigned int D.46589;
  struct MonoDomain * D.46595;
  long int D.46598;
  struct MonoInst * D.46599;
  int D.46600;
  int D.46601;
  long int vt.432;
  long int D.46607;
  struct MonoInst * D.46608;
  int D.46609;
  int D.46610;
  long int D.46614;
  struct MonoInst * D.46615;
  int D.46616;
  int D.46617;
  long int klass.433;
  long int D.46622;
  struct MonoInst * D.46623;
  int D.46624;
  int D.46625;
  unsigned int D.46628;
  unsigned int D.46629;
  int D.46630;
  unsigned char * D.46634;
  long int D.46637;
  long int D.46638;
  long unsigned int D.46639;
  long unsigned int D.46640;
  struct MonoBasicBlock * * D.46641;
  void * D.46657;
  struct MonoBasicBlock * * D.46658;
  struct MonoBasicBlock * * D.46659;
  unsigned int D.46665;
  unsigned int D.46666;
  int D.46667;
  long int D.46685;
  struct MonoInst * D.46686;
  int D.46687;
  int D.46688;
  unsigned int D.46691;
  unsigned int D.46692;
  int D.46693;
  unsigned char * D.46697;
  long int D.46700;
  long int D.46701;
  long unsigned int D.46702;
  long unsigned int D.46703;
  struct MonoBasicBlock * * D.46704;
  void * D.46720;
  struct MonoBasicBlock * * D.46721;
  struct MonoBasicBlock * * D.46722;
  unsigned int D.46728;
  unsigned int D.46729;
  int D.46730;
  long int D.46748;
  struct MonoInst * D.46749;
  int D.46750;
  int D.46751;
  unsigned char * D.46755;
  long int D.46758;
  long int D.46759;
  long unsigned int D.46760;
  long unsigned int D.46761;
  struct MonoBasicBlock * * D.46762;
  long int D.46777;
  struct MonoInst * D.46778;
  int D.46779;
  int D.46780;
  long int D.46784;
  struct MonoInst * D.46785;
  int D.46786;
  int D.46787;
  unsigned int D.46790;
  unsigned int D.46791;
  int D.46792;
  unsigned char * D.46796;
  long int D.46799;
  long int D.46800;
  long unsigned int D.46801;
  long unsigned int D.46802;
  struct MonoBasicBlock * * D.46803;
  void * D.46819;
  struct MonoBasicBlock * * D.46820;
  struct MonoBasicBlock * * D.46821;
  unsigned int D.46827;
  unsigned int D.46828;
  int D.46829;
  unsigned char * D.46847;
  long int D.46850;
  long int D.46851;
  long unsigned int D.46852;
  long unsigned int D.46853;
  struct MonoBasicBlock * * D.46854;
  unsigned char * D.46869;
  long int D.46872;
  long int D.46873;
  long unsigned int D.46874;
  long unsigned int D.46875;
  struct MonoBasicBlock * * D.46876;
  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.46030 = alloc_preg (cfg);
  vtable_reg = (int) D.46030;
  D.46031 = alloc_ireg_ref (cfg);
  res_reg = (int) D.46031;
  klass_inst = 0B;
  if (context_used != 0) goto <D.46032>; else goto <D.46033>;
  <D.46032>:
  {
    struct MonoInst * args[3];

    try
      {
        mini_class_has_reference_variant_generic_argument (cfg, klass, context_used);
        if (1 != 0) goto <D.46034>; else goto <D.46035>;
        <D.46034>:
        {
          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.46036 = cfg->mempool;
          D.46037 = mono_mempool_alloc (D.46036, 80);
          args[1] = D.46037;
          D.46038 = args[1];
          D.46038 = args[1];
          D.46038->data.op[1].const_val = 0;
          D.46039 = D.46038->data.op[1].const_val;
          D.46038->data.op[0].const_val = D.46039;
          D.46038 = args[1];
          D.46038 = args[1];
          D.46038->prev = 0B;
          D.46040 = D.46038->prev;
          D.46038->next = D.46040;
          D.46038 = args[1];
          D.46038->opcode = 388;
          D.46038 = args[1];
          D.46038->flags = 0;
          D.46038 = args[1];
          D.46038->type = 0;
          D.46038 = args[1];
          D.46038->dreg = -1;
          D.46038 = args[1];
          D.46038 = args[1];
          D.46038 = args[1];
          D.46038->sreg3 = -1;
          D.46041 = D.46038->sreg3;
          D.46038->sreg2 = D.46041;
          D.46042 = D.46038->sreg2;
          D.46038->sreg1 = D.46042;
          D.46038 = args[1];
          D.46043 = cfg->ip;
          D.46038->cil_code = D.46043;
          D.46038 = args[1];
          D.46044 = alloc_preg (cfg);
          D.46045 = (int) D.46044;
          D.46038->dreg = D.46045;
          D.46038 = args[1];
          D.46046 = cache_ins->dreg;
          D.46038->sreg1 = D.46046;
          D.46038 = args[1];
          D.46038->data.op[0].const_val = 8;
          D.46038 = args[1];
          D.46038->type = 1;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46049>; else goto <D.46050>;
          <D.46049>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46038 = args[1];
          D.46048->next = D.46038;
          D.46038 = args[1];
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46038->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46038 = args[1];
          D.46047->last_ins = D.46038;
          goto <D.46051>;
          <D.46050>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46038 = args[1];
          D.46047->last_ins = D.46038;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46051>:
          args[2] = cache_ins;
          D.46052 = mono_emit_method_call (cfg, mono_isinst, &args, 0B);
          return D.46052;
        }
        <D.46035>:
        klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, 1);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  <D.46033>:
  D.46036 = cfg->mempool;
  is_null_bb = mono_mempool_alloc0 (D.46036, 296);
  D.46053 = cfg->num_bblocks;
  D.46054 = D.46053;
  D.46055 = D.46054 + 1;
  cfg->num_bblocks = D.46055;
  D.46056 = (int) D.46054;
  is_null_bb->block_num = D.46056;
  D.46036 = cfg->mempool;
  false_bb = mono_mempool_alloc0 (D.46036, 296);
  D.46053 = cfg->num_bblocks;
  D.46057 = D.46053;
  D.46058 = D.46057 + 1;
  cfg->num_bblocks = D.46058;
  D.46059 = (int) D.46057;
  false_bb->block_num = D.46059;
  D.46036 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.46036, 296);
  D.46053 = cfg->num_bblocks;
  D.46060 = D.46053;
  D.46061 = D.46060 + 1;
  cfg->num_bblocks = D.46061;
  D.46062 = (int) D.46060;
  end_bb->block_num = D.46062;
  D.46036 = cfg->mempool;
  ins = mono_mempool_alloc (D.46036, 80);
  ins->data.op[1].const_val = 0;
  D.46063 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.46063;
  ins->prev = 0B;
  D.46064 = ins->prev;
  ins->next = D.46064;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.46065 = ins->sreg3;
  ins->sreg2 = D.46065;
  D.46066 = ins->sreg2;
  ins->sreg1 = D.46066;
  D.46043 = cfg->ip;
  ins->cil_code = D.46043;
  ins->dreg = res_reg;
  ins->sreg1 = obj_reg;
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 != 0B) goto <D.46067>; else goto <D.46068>;
  <D.46067>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46048->next = ins;
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  ins->prev = D.46048;
  D.46047 = cfg->cbb;
  D.46047->last_ins = ins;
  goto <D.46069>;
  <D.46068>:
  D.46047 = cfg->cbb;
  D.46047 = cfg->cbb;
  D.46047->last_ins = ins;
  D.46048 = D.46047->last_ins;
  D.46047->code = D.46048;
  <D.46069>:
  ins->type = 6;
  ins->klass = klass;
  {
    struct MonoInst * inst;

    D.46036 = cfg->mempool;
    inst = mono_mempool_alloc (D.46036, 80);
    inst->data.op[1].const_val = 0;
    D.46070 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46070;
    inst->prev = 0B;
    D.46071 = inst->prev;
    inst->next = D.46071;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46072 = inst->sreg3;
    inst->sreg2 = D.46072;
    D.46073 = inst->sreg2;
    inst->sreg1 = D.46073;
    D.46043 = cfg->ip;
    inst->cil_code = D.46043;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46074>; else goto <D.46075>;
    <D.46074>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = inst;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    inst->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    goto <D.46076>;
    <D.46075>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46076>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.46036 = cfg->mempool;
    ins = mono_mempool_alloc (D.46036, 80);
    ins->data.op[1].const_val = 0;
    D.46077 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.46077;
    ins->prev = 0B;
    D.46078 = ins->prev;
    ins->next = D.46078;
    ins->opcode = 648;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.46079 = ins->sreg3;
    ins->sreg2 = D.46079;
    D.46080 = ins->sreg2;
    ins->sreg1 = D.46080;
    D.46043 = cfg->ip;
    ins->cil_code = D.46043;
    if (0 != 0) goto <D.46081>; else goto <D.46082>;
    <D.46081>:
    D.46036 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46036, 296);
    D.46053 = cfg->num_bblocks;
    D.46083 = D.46053;
    D.46084 = D.46083 + 1;
    cfg->num_bblocks = D.46084;
    D.46085 = (int) D.46083;
    falsebb->block_num = D.46085;
    ins->data.op[0].target_block = is_null_bb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, is_null_bb);
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46086>; else goto <D.46087>;
    <D.46086>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = ins;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    ins->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    goto <D.46088>;
    <D.46087>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46088>:
    D.46089 = falsebb->cil_code;
    if (D.46089 != 0B) goto <D.46090>; else goto <D.46091>;
    <D.46090>:
    D.46092 = cfg->cil_offset_to_bb;
    D.46089 = falsebb->cil_code;
    D.46093 = (long int) D.46089;
    D.46094 = cfg->cil_start;
    D.46095 = (long int) D.46094;
    D.46096 = D.46093 - D.46095;
    D.46097 = (long unsigned int) D.46096;
    D.46098 = D.46097 * 8;
    D.46099 = D.46092 + D.46098;
    *D.46099 = falsebb;
    <D.46091>:
    D.46100 = cfg->real_offset;
    falsebb->real_offset = D.46100;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46104>; else goto <D.46101>;
    <D.46104>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 <= 9) goto <D.46102>; else goto <D.46107>;
    <D.46107>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 <= 9) goto <D.46102>; else goto <D.46109>;
    <D.46109>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 <= 9) goto <D.46102>; else goto <D.46101>;
    <D.46102>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    D.46113 = *D.46112;
    if (D.46113 == 0B) goto <D.46114>; else goto <D.46101>;
    <D.46114>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    *D.46112 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    goto <D.46103>;
    <D.46101>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 == 0B) goto <D.46115>; else goto <D.46117>;
    <D.46117>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 442) goto <D.46118>; else goto <D.46116>;
    <D.46118>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 759) goto <D.46119>; else goto <D.46116>;
    <D.46119>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 > 9) goto <D.46120>; else goto <D.46116>;
    <D.46120>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 > 9) goto <D.46121>; else goto <D.46116>;
    <D.46121>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 > 9) goto <D.46115>; else goto <D.46116>;
    <D.46115>:
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    <D.46116>:
    <D.46103>:
    D.46047 = cfg->cbb;
    D.46047->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46122>;
    <D.46082>:
    D.46036 = cfg->mempool;
    D.46123 = mono_mempool_alloc (D.46036, 16);
    ins->data.op[1].many_blocks = D.46123;
    D.46124 = ins->data.op[1].many_blocks;
    *D.46124 = is_null_bb;
    D.46124 = ins->data.op[1].many_blocks;
    D.46125 = D.46124 + 8;
    *D.46125 = 0B;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, is_null_bb);
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46126>; else goto <D.46127>;
    <D.46126>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = ins;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    ins->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    goto <D.46128>;
    <D.46127>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46128>:
    D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.46130 = D.46129 & 34359738368;
    if (D.46130 == 0) goto <D.46131>; else goto <D.46132>;
    <D.46131>:
    D.46036 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46036, 296);
    D.46053 = cfg->num_bblocks;
    D.46133 = D.46053;
    D.46134 = D.46133 + 1;
    cfg->num_bblocks = D.46134;
    D.46135 = (int) D.46133;
    falsebb->block_num = D.46135;
    D.46124 = ins->data.op[1].many_blocks;
    D.46125 = D.46124 + 8;
    *D.46125 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    D.46089 = falsebb->cil_code;
    if (D.46089 != 0B) goto <D.46136>; else goto <D.46137>;
    <D.46136>:
    D.46092 = cfg->cil_offset_to_bb;
    D.46089 = falsebb->cil_code;
    D.46093 = (long int) D.46089;
    D.46094 = cfg->cil_start;
    D.46095 = (long int) D.46094;
    D.46096 = D.46093 - D.46095;
    D.46097 = (long unsigned int) D.46096;
    D.46098 = D.46097 * 8;
    D.46099 = D.46092 + D.46098;
    *D.46099 = falsebb;
    <D.46137>:
    D.46100 = cfg->real_offset;
    falsebb->real_offset = D.46100;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46141>; else goto <D.46138>;
    <D.46141>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 <= 9) goto <D.46139>; else goto <D.46142>;
    <D.46142>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 <= 9) goto <D.46139>; else goto <D.46143>;
    <D.46143>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 <= 9) goto <D.46139>; else goto <D.46138>;
    <D.46139>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    D.46113 = *D.46112;
    if (D.46113 == 0B) goto <D.46144>; else goto <D.46138>;
    <D.46144>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    *D.46112 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    goto <D.46140>;
    <D.46138>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 == 0B) goto <D.46145>; else goto <D.46147>;
    <D.46147>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 442) goto <D.46148>; else goto <D.46146>;
    <D.46148>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 759) goto <D.46149>; else goto <D.46146>;
    <D.46149>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 > 9) goto <D.46150>; else goto <D.46146>;
    <D.46150>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 > 9) goto <D.46151>; else goto <D.46146>;
    <D.46151>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 > 9) goto <D.46145>; else goto <D.46146>;
    <D.46145>:
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    <D.46146>:
    <D.46140>:
    D.46047 = cfg->cbb;
    D.46047->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46152>;
    <D.46132>:
    D.46047 = cfg->cbb;
    D.46047->extended = 1;
    <D.46152>:
    <D.46122>:
  }
  {
    struct MonoInst * inst;

    D.46036 = cfg->mempool;
    inst = mono_mempool_alloc (D.46036, 80);
    inst->data.op[1].const_val = 0;
    D.46153 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46153;
    inst->prev = 0B;
    D.46154 = inst->prev;
    inst->next = D.46154;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46155 = inst->sreg3;
    inst->sreg2 = D.46155;
    D.46156 = inst->sreg2;
    inst->sreg1 = D.46156;
    D.46043 = cfg->ip;
    inst->cil_code = D.46043;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46157>; else goto <D.46158>;
    <D.46157>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = inst;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    inst->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    goto <D.46159>;
    <D.46158>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46159>:
  }
  D.46160 = klass->flags;
  D.46161 = D.46160 & 32;
  if (D.46161 != 0) goto <D.46162>; else goto <D.46163>;
  <D.46162>:
  D.46164 = context_used != 0;
  D.46165 = (long int) D.46164;
  D.46166 = __builtin_expect (D.46165, 0);
  if (D.46166 != 0) goto <D.46167>; else goto <D.46168>;
  <D.46167>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4086, "!context_used");
  <D.46168>:
  mini_emit_iface_cast (cfg, vtable_reg, klass, false_bb, is_null_bb);
  goto <D.46169>;
  <D.46163>:
  {
    int klass_reg;

    D.46170 = alloc_preg (cfg);
    klass_reg = (int) D.46170;
    D.46171 = klass->rank;
    if (D.46171 != 0) goto <D.46172>; else goto <D.46173>;
    <D.46172>:
    {
      int rank_reg;
      int eclass_reg;

      D.46174 = alloc_preg (cfg);
      rank_reg = (int) D.46174;
      D.46175 = alloc_preg (cfg);
      eclass_reg = (int) D.46175;
      D.46164 = context_used != 0;
      D.46165 = (long int) D.46164;
      D.46166 = __builtin_expect (D.46165, 0);
      if (D.46166 != 0) goto <D.46176>; else goto <D.46177>;
      <D.46176>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4096, "!context_used");
      <D.46177>:
      {
        struct MonoInst * inst;

        D.46036 = cfg->mempool;
        inst = mono_mempool_alloc (D.46036, 80);
        inst->data.op[1].const_val = 0;
        D.46178 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.46178;
        inst->prev = 0B;
        D.46179 = inst->prev;
        inst->next = D.46179;
        inst->opcode = 390;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.46180 = inst->sreg3;
        inst->sreg2 = D.46180;
        D.46181 = inst->sreg2;
        inst->sreg1 = D.46181;
        D.46043 = cfg->ip;
        inst->cil_code = D.46043;
        inst->dreg = rank_reg;
        inst->sreg1 = vtable_reg;
        inst->data.op[0].const_val = 42;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46182>; else goto <D.46183>;
        <D.46182>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = inst;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        inst->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        goto <D.46184>;
        <D.46183>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46184>:
      }
      {
        struct MonoInst * inst;

        D.46036 = cfg->mempool;
        inst = mono_mempool_alloc (D.46036, 80);
        inst->data.op[1].const_val = 0;
        D.46185 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.46185;
        inst->prev = 0B;
        D.46186 = inst->prev;
        inst->next = D.46186;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.46187 = inst->sreg3;
        inst->sreg2 = D.46187;
        D.46188 = inst->sreg2;
        inst->sreg1 = D.46188;
        D.46043 = cfg->ip;
        inst->cil_code = D.46043;
        inst->dreg = -1;
        inst->sreg1 = rank_reg;
        D.46171 = klass->rank;
        D.46189 = (long int) D.46171;
        inst->data.op[1].const_val = D.46189;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46190>; else goto <D.46191>;
        <D.46190>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = inst;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        inst->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        goto <D.46192>;
        <D.46191>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46192>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.46036 = cfg->mempool;
        ins = mono_mempool_alloc (D.46036, 80);
        ins->data.op[1].const_val = 0;
        D.46193 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.46193;
        ins->prev = 0B;
        D.46194 = ins->prev;
        ins->next = D.46194;
        ins->opcode = 556;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.46195 = ins->sreg3;
        ins->sreg2 = D.46195;
        D.46196 = ins->sreg2;
        ins->sreg1 = D.46196;
        D.46043 = cfg->ip;
        ins->cil_code = D.46043;
        if (0 != 0) goto <D.46197>; else goto <D.46198>;
        <D.46197>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46199 = D.46053;
        D.46200 = D.46199 + 1;
        cfg->num_bblocks = D.46200;
        D.46201 = (int) D.46199;
        falsebb->block_num = D.46201;
        ins->data.op[0].target_block = false_bb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46202>; else goto <D.46203>;
        <D.46202>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46204>;
        <D.46203>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46204>:
        D.46205 = falsebb->cil_code;
        if (D.46205 != 0B) goto <D.46206>; else goto <D.46207>;
        <D.46206>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46205 = falsebb->cil_code;
        D.46208 = (long int) D.46205;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46209 = D.46208 - D.46095;
        D.46210 = (long unsigned int) D.46209;
        D.46211 = D.46210 * 8;
        D.46212 = D.46092 + D.46211;
        *D.46212 = falsebb;
        <D.46207>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46216>; else goto <D.46213>;
        <D.46216>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46214>; else goto <D.46217>;
        <D.46217>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46214>; else goto <D.46218>;
        <D.46218>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46214>; else goto <D.46213>;
        <D.46214>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46219>; else goto <D.46213>;
        <D.46219>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46215>;
        <D.46213>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46220>; else goto <D.46222>;
        <D.46222>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46223>; else goto <D.46221>;
        <D.46223>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46224>; else goto <D.46221>;
        <D.46224>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46225>; else goto <D.46221>;
        <D.46225>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46226>; else goto <D.46221>;
        <D.46226>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46220>; else goto <D.46221>;
        <D.46220>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46221>:
        <D.46215>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46227>;
        <D.46198>:
        D.46036 = cfg->mempool;
        D.46228 = mono_mempool_alloc (D.46036, 16);
        ins->data.op[1].many_blocks = D.46228;
        D.46229 = ins->data.op[1].many_blocks;
        *D.46229 = false_bb;
        D.46229 = ins->data.op[1].many_blocks;
        D.46230 = D.46229 + 8;
        *D.46230 = 0B;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46231>; else goto <D.46232>;
        <D.46231>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46233>;
        <D.46232>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46233>:
        D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.46130 = D.46129 & 34359738368;
        if (D.46130 == 0) goto <D.46234>; else goto <D.46235>;
        <D.46234>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46236 = D.46053;
        D.46237 = D.46236 + 1;
        cfg->num_bblocks = D.46237;
        D.46238 = (int) D.46236;
        falsebb->block_num = D.46238;
        D.46229 = ins->data.op[1].many_blocks;
        D.46230 = D.46229 + 8;
        *D.46230 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        D.46205 = falsebb->cil_code;
        if (D.46205 != 0B) goto <D.46239>; else goto <D.46240>;
        <D.46239>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46205 = falsebb->cil_code;
        D.46208 = (long int) D.46205;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46209 = D.46208 - D.46095;
        D.46210 = (long unsigned int) D.46209;
        D.46211 = D.46210 * 8;
        D.46212 = D.46092 + D.46211;
        *D.46212 = falsebb;
        <D.46240>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46244>; else goto <D.46241>;
        <D.46244>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46242>; else goto <D.46245>;
        <D.46245>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46242>; else goto <D.46246>;
        <D.46246>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46242>; else goto <D.46241>;
        <D.46242>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46247>; else goto <D.46241>;
        <D.46247>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46243>;
        <D.46241>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46248>; else goto <D.46250>;
        <D.46250>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46251>; else goto <D.46249>;
        <D.46251>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46252>; else goto <D.46249>;
        <D.46252>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46253>; else goto <D.46249>;
        <D.46253>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46254>; else goto <D.46249>;
        <D.46254>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46248>; else goto <D.46249>;
        <D.46248>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46249>:
        <D.46243>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46255>;
        <D.46235>:
        D.46047 = cfg->cbb;
        D.46047->extended = 1;
        <D.46255>:
        <D.46227>:
      }
      {
        struct MonoInst * inst;

        D.46036 = cfg->mempool;
        inst = mono_mempool_alloc (D.46036, 80);
        inst->data.op[1].const_val = 0;
        D.46256 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.46256;
        inst->prev = 0B;
        D.46257 = inst->prev;
        inst->next = D.46257;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.46258 = inst->sreg3;
        inst->sreg2 = D.46258;
        D.46259 = inst->sreg2;
        inst->sreg1 = D.46259;
        D.46043 = cfg->ip;
        inst->cil_code = D.46043;
        inst->dreg = klass_reg;
        inst->sreg1 = vtable_reg;
        inst->data.op[0].const_val = 0;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46260>; else goto <D.46261>;
        <D.46260>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = inst;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        inst->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        goto <D.46262>;
        <D.46261>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46262>:
      }
      {
        struct MonoInst * inst;

        D.46036 = cfg->mempool;
        inst = mono_mempool_alloc (D.46036, 80);
        inst->data.op[1].const_val = 0;
        D.46263 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.46263;
        inst->prev = 0B;
        D.46264 = inst->prev;
        inst->next = D.46264;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.46265 = inst->sreg3;
        inst->sreg2 = D.46265;
        D.46266 = inst->sreg2;
        inst->sreg1 = D.46266;
        D.46043 = cfg->ip;
        inst->cil_code = D.46043;
        inst->dreg = eclass_reg;
        inst->sreg1 = klass_reg;
        inst->data.op[0].const_val = 8;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46267>; else goto <D.46268>;
        <D.46267>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = inst;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        inst->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        goto <D.46269>;
        <D.46268>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46269>:
      }
      D.46270 = klass->cast_class;
      D.46271 = mono_defaults.object_class;
      if (D.46270 == D.46271) goto <D.46272>; else goto <D.46273>;
      <D.46272>:
      {
        int parent_reg;

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

          D.46036 = cfg->mempool;
          inst = mono_mempool_alloc (D.46036, 80);
          inst->data.op[1].const_val = 0;
          D.46275 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.46275;
          inst->prev = 0B;
          D.46276 = inst->prev;
          inst->next = D.46276;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.46277 = inst->sreg3;
          inst->sreg2 = D.46277;
          D.46278 = inst->sreg2;
          inst->sreg1 = D.46278;
          D.46043 = cfg->ip;
          inst->cil_code = D.46043;
          inst->dreg = parent_reg;
          inst->sreg1 = eclass_reg;
          inst->data.op[0].const_val = 40;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46279>; else goto <D.46280>;
          <D.46279>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = inst;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          inst->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          goto <D.46281>;
          <D.46280>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46281>:
        }
        D.46282 = mono_defaults.enum_class;
        D.46283 = D.46282->parent;
        mini_emit_class_check_branch (cfg, parent_reg, D.46283, 556, is_null_bb);
        D.46282 = mono_defaults.enum_class;
        mini_emit_class_check_branch (cfg, eclass_reg, D.46282, 551, is_null_bb);
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.46036 = cfg->mempool;
          ins = mono_mempool_alloc (D.46036, 80);
          ins->data.op[1].const_val = 0;
          D.46284 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.46284;
          ins->prev = 0B;
          D.46285 = ins->prev;
          ins->next = D.46285;
          ins->opcode = 442;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.46286 = ins->sreg3;
          ins->sreg2 = D.46286;
          D.46287 = ins->sreg2;
          ins->sreg1 = D.46287;
          D.46043 = cfg->ip;
          ins->cil_code = D.46043;
          if (1 != 0) goto <D.46288>; else goto <D.46289>;
          <D.46288>:
          D.46036 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.46036, 296);
          D.46053 = cfg->num_bblocks;
          D.46290 = D.46053;
          D.46291 = D.46290 + 1;
          cfg->num_bblocks = D.46291;
          D.46292 = (int) D.46290;
          falsebb->block_num = D.46292;
          ins->data.op[0].target_block = false_bb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, false_bb);
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46293>; else goto <D.46294>;
          <D.46293>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = ins;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          ins->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          goto <D.46295>;
          <D.46294>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46295>:
          D.46296 = falsebb->cil_code;
          if (D.46296 != 0B) goto <D.46297>; else goto <D.46298>;
          <D.46297>:
          D.46092 = cfg->cil_offset_to_bb;
          D.46296 = falsebb->cil_code;
          D.46299 = (long int) D.46296;
          D.46094 = cfg->cil_start;
          D.46095 = (long int) D.46094;
          D.46300 = D.46299 - D.46095;
          D.46301 = (long unsigned int) D.46300;
          D.46302 = D.46301 * 8;
          D.46303 = D.46092 + D.46302;
          *D.46303 = falsebb;
          <D.46298>:
          D.46100 = cfg->real_offset;
          falsebb->real_offset = D.46100;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46307>; else goto <D.46304>;
          <D.46307>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 <= 9) goto <D.46305>; else goto <D.46308>;
          <D.46308>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 <= 9) goto <D.46305>; else goto <D.46309>;
          <D.46309>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 <= 9) goto <D.46305>; else goto <D.46304>;
          <D.46305>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          D.46113 = *D.46112;
          if (D.46113 == 0B) goto <D.46310>; else goto <D.46304>;
          <D.46310>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          *D.46112 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          goto <D.46306>;
          <D.46304>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 == 0B) goto <D.46311>; else goto <D.46313>;
          <D.46313>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 442) goto <D.46314>; else goto <D.46312>;
          <D.46314>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 759) goto <D.46315>; else goto <D.46312>;
          <D.46315>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 > 9) goto <D.46316>; else goto <D.46312>;
          <D.46316>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 > 9) goto <D.46317>; else goto <D.46312>;
          <D.46317>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 > 9) goto <D.46311>; else goto <D.46312>;
          <D.46311>:
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          <D.46312>:
          <D.46306>:
          D.46047 = cfg->cbb;
          D.46047->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.46318>;
          <D.46289>:
          D.46036 = cfg->mempool;
          D.46319 = mono_mempool_alloc (D.46036, 16);
          ins->data.op[1].many_blocks = D.46319;
          D.46320 = ins->data.op[1].many_blocks;
          *D.46320 = false_bb;
          D.46320 = ins->data.op[1].many_blocks;
          D.46321 = D.46320 + 8;
          *D.46321 = 0B;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, false_bb);
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46322>; else goto <D.46323>;
          <D.46322>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = ins;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          ins->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          goto <D.46324>;
          <D.46323>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46324>:
          D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.46130 = D.46129 & 34359738368;
          if (D.46130 == 0) goto <D.46325>; else goto <D.46326>;
          <D.46325>:
          D.46036 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.46036, 296);
          D.46053 = cfg->num_bblocks;
          D.46327 = D.46053;
          D.46328 = D.46327 + 1;
          cfg->num_bblocks = D.46328;
          D.46329 = (int) D.46327;
          falsebb->block_num = D.46329;
          D.46320 = ins->data.op[1].many_blocks;
          D.46321 = D.46320 + 8;
          *D.46321 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          D.46296 = falsebb->cil_code;
          if (D.46296 != 0B) goto <D.46330>; else goto <D.46331>;
          <D.46330>:
          D.46092 = cfg->cil_offset_to_bb;
          D.46296 = falsebb->cil_code;
          D.46299 = (long int) D.46296;
          D.46094 = cfg->cil_start;
          D.46095 = (long int) D.46094;
          D.46300 = D.46299 - D.46095;
          D.46301 = (long unsigned int) D.46300;
          D.46302 = D.46301 * 8;
          D.46303 = D.46092 + D.46302;
          *D.46303 = falsebb;
          <D.46331>:
          D.46100 = cfg->real_offset;
          falsebb->real_offset = D.46100;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46335>; else goto <D.46332>;
          <D.46335>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 <= 9) goto <D.46333>; else goto <D.46336>;
          <D.46336>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 <= 9) goto <D.46333>; else goto <D.46337>;
          <D.46337>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 <= 9) goto <D.46333>; else goto <D.46332>;
          <D.46333>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          D.46113 = *D.46112;
          if (D.46113 == 0B) goto <D.46338>; else goto <D.46332>;
          <D.46338>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          *D.46112 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          goto <D.46334>;
          <D.46332>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 == 0B) goto <D.46339>; else goto <D.46341>;
          <D.46341>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 442) goto <D.46342>; else goto <D.46340>;
          <D.46342>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 759) goto <D.46343>; else goto <D.46340>;
          <D.46343>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 > 9) goto <D.46344>; else goto <D.46340>;
          <D.46344>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 > 9) goto <D.46345>; else goto <D.46340>;
          <D.46345>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 > 9) goto <D.46339>; else goto <D.46340>;
          <D.46339>:
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          <D.46340>:
          <D.46334>:
          D.46047 = cfg->cbb;
          D.46047->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.46346>;
          <D.46326>:
          D.46047 = cfg->cbb;
          D.46047->extended = 1;
          <D.46346>:
          <D.46318>:
        }
      }
      goto <D.46347>;
      <D.46273>:
      D.46270 = klass->cast_class;
      D.46282 = mono_defaults.enum_class;
      D.46283 = D.46282->parent;
      if (D.46270 == D.46283) goto <D.46348>; else goto <D.46349>;
      <D.46348>:
      D.46282 = mono_defaults.enum_class;
      D.46283 = D.46282->parent;
      mini_emit_class_check_branch (cfg, eclass_reg, D.46283, 551, is_null_bb);
      D.46282 = mono_defaults.enum_class;
      mini_emit_class_check_branch (cfg, eclass_reg, D.46282, 551, is_null_bb);
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.46036 = cfg->mempool;
        ins = mono_mempool_alloc (D.46036, 80);
        ins->data.op[1].const_val = 0;
        D.46350 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.46350;
        ins->prev = 0B;
        D.46351 = ins->prev;
        ins->next = D.46351;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.46352 = ins->sreg3;
        ins->sreg2 = D.46352;
        D.46353 = ins->sreg2;
        ins->sreg1 = D.46353;
        D.46043 = cfg->ip;
        ins->cil_code = D.46043;
        if (1 != 0) goto <D.46354>; else goto <D.46355>;
        <D.46354>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46356 = D.46053;
        D.46357 = D.46356 + 1;
        cfg->num_bblocks = D.46357;
        D.46358 = (int) D.46356;
        falsebb->block_num = D.46358;
        ins->data.op[0].target_block = false_bb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46359>; else goto <D.46360>;
        <D.46359>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46361>;
        <D.46360>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46361>:
        D.46362 = falsebb->cil_code;
        if (D.46362 != 0B) goto <D.46363>; else goto <D.46364>;
        <D.46363>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46362 = falsebb->cil_code;
        D.46365 = (long int) D.46362;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46366 = D.46365 - D.46095;
        D.46367 = (long unsigned int) D.46366;
        D.46368 = D.46367 * 8;
        D.46369 = D.46092 + D.46368;
        *D.46369 = falsebb;
        <D.46364>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46373>; else goto <D.46370>;
        <D.46373>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46371>; else goto <D.46374>;
        <D.46374>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46371>; else goto <D.46375>;
        <D.46375>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46371>; else goto <D.46370>;
        <D.46371>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46376>; else goto <D.46370>;
        <D.46376>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46372>;
        <D.46370>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46377>; else goto <D.46379>;
        <D.46379>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46380>; else goto <D.46378>;
        <D.46380>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46381>; else goto <D.46378>;
        <D.46381>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46382>; else goto <D.46378>;
        <D.46382>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46383>; else goto <D.46378>;
        <D.46383>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46377>; else goto <D.46378>;
        <D.46377>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46378>:
        <D.46372>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46384>;
        <D.46355>:
        D.46036 = cfg->mempool;
        D.46385 = mono_mempool_alloc (D.46036, 16);
        ins->data.op[1].many_blocks = D.46385;
        D.46386 = ins->data.op[1].many_blocks;
        *D.46386 = false_bb;
        D.46386 = ins->data.op[1].many_blocks;
        D.46387 = D.46386 + 8;
        *D.46387 = 0B;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46388>; else goto <D.46389>;
        <D.46388>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46390>;
        <D.46389>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46390>:
        D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.46130 = D.46129 & 34359738368;
        if (D.46130 == 0) goto <D.46391>; else goto <D.46392>;
        <D.46391>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46393 = D.46053;
        D.46394 = D.46393 + 1;
        cfg->num_bblocks = D.46394;
        D.46395 = (int) D.46393;
        falsebb->block_num = D.46395;
        D.46386 = ins->data.op[1].many_blocks;
        D.46387 = D.46386 + 8;
        *D.46387 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        D.46362 = falsebb->cil_code;
        if (D.46362 != 0B) goto <D.46396>; else goto <D.46397>;
        <D.46396>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46362 = falsebb->cil_code;
        D.46365 = (long int) D.46362;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46366 = D.46365 - D.46095;
        D.46367 = (long unsigned int) D.46366;
        D.46368 = D.46367 * 8;
        D.46369 = D.46092 + D.46368;
        *D.46369 = falsebb;
        <D.46397>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46401>; else goto <D.46398>;
        <D.46401>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46399>; else goto <D.46402>;
        <D.46402>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46399>; else goto <D.46403>;
        <D.46403>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46399>; else goto <D.46398>;
        <D.46399>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46404>; else goto <D.46398>;
        <D.46404>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46400>;
        <D.46398>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46405>; else goto <D.46407>;
        <D.46407>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46408>; else goto <D.46406>;
        <D.46408>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46409>; else goto <D.46406>;
        <D.46409>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46410>; else goto <D.46406>;
        <D.46410>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46411>; else goto <D.46406>;
        <D.46411>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46405>; else goto <D.46406>;
        <D.46405>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46406>:
        <D.46400>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46412>;
        <D.46392>:
        D.46047 = cfg->cbb;
        D.46047->extended = 1;
        <D.46412>:
        <D.46384>:
      }
      goto <D.46413>;
      <D.46349>:
      D.46270 = klass->cast_class;
      D.46282 = mono_defaults.enum_class;
      if (D.46270 == D.46282) goto <D.46414>; else goto <D.46415>;
      <D.46414>:
      D.46282 = mono_defaults.enum_class;
      mini_emit_class_check_branch (cfg, eclass_reg, D.46282, 551, is_null_bb);
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.46036 = cfg->mempool;
        ins = mono_mempool_alloc (D.46036, 80);
        ins->data.op[1].const_val = 0;
        D.46416 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.46416;
        ins->prev = 0B;
        D.46417 = ins->prev;
        ins->next = D.46417;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.46418 = ins->sreg3;
        ins->sreg2 = D.46418;
        D.46419 = ins->sreg2;
        ins->sreg1 = D.46419;
        D.46043 = cfg->ip;
        ins->cil_code = D.46043;
        if (1 != 0) goto <D.46420>; else goto <D.46421>;
        <D.46420>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46422 = D.46053;
        D.46423 = D.46422 + 1;
        cfg->num_bblocks = D.46423;
        D.46424 = (int) D.46422;
        falsebb->block_num = D.46424;
        ins->data.op[0].target_block = false_bb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46425>; else goto <D.46426>;
        <D.46425>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46427>;
        <D.46426>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46427>:
        D.46428 = falsebb->cil_code;
        if (D.46428 != 0B) goto <D.46429>; else goto <D.46430>;
        <D.46429>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46428 = falsebb->cil_code;
        D.46431 = (long int) D.46428;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46432 = D.46431 - D.46095;
        D.46433 = (long unsigned int) D.46432;
        D.46434 = D.46433 * 8;
        D.46435 = D.46092 + D.46434;
        *D.46435 = falsebb;
        <D.46430>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46439>; else goto <D.46436>;
        <D.46439>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46437>; else goto <D.46440>;
        <D.46440>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46437>; else goto <D.46441>;
        <D.46441>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46437>; else goto <D.46436>;
        <D.46437>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46442>; else goto <D.46436>;
        <D.46442>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46438>;
        <D.46436>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46443>; else goto <D.46445>;
        <D.46445>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46446>; else goto <D.46444>;
        <D.46446>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46447>; else goto <D.46444>;
        <D.46447>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46448>; else goto <D.46444>;
        <D.46448>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46449>; else goto <D.46444>;
        <D.46449>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46443>; else goto <D.46444>;
        <D.46443>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46444>:
        <D.46438>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46450>;
        <D.46421>:
        D.46036 = cfg->mempool;
        D.46451 = mono_mempool_alloc (D.46036, 16);
        ins->data.op[1].many_blocks = D.46451;
        D.46452 = ins->data.op[1].many_blocks;
        *D.46452 = false_bb;
        D.46452 = ins->data.op[1].many_blocks;
        D.46453 = D.46452 + 8;
        *D.46453 = 0B;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, false_bb);
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46454>; else goto <D.46455>;
        <D.46454>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = ins;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        ins->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        goto <D.46456>;
        <D.46455>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = ins;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46456>:
        D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.46130 = D.46129 & 34359738368;
        if (D.46130 == 0) goto <D.46457>; else goto <D.46458>;
        <D.46457>:
        D.46036 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.46036, 296);
        D.46053 = cfg->num_bblocks;
        D.46459 = D.46053;
        D.46460 = D.46459 + 1;
        cfg->num_bblocks = D.46460;
        D.46461 = (int) D.46459;
        falsebb->block_num = D.46461;
        D.46452 = ins->data.op[1].many_blocks;
        D.46453 = D.46452 + 8;
        *D.46453 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        D.46428 = falsebb->cil_code;
        if (D.46428 != 0B) goto <D.46462>; else goto <D.46463>;
        <D.46462>:
        D.46092 = cfg->cil_offset_to_bb;
        D.46428 = falsebb->cil_code;
        D.46431 = (long int) D.46428;
        D.46094 = cfg->cil_start;
        D.46095 = (long int) D.46094;
        D.46432 = D.46431 - D.46095;
        D.46433 = (long unsigned int) D.46432;
        D.46434 = D.46433 * 8;
        D.46435 = D.46092 + D.46434;
        *D.46435 = falsebb;
        <D.46463>:
        D.46100 = cfg->real_offset;
        falsebb->real_offset = D.46100;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46467>; else goto <D.46464>;
        <D.46467>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 <= 9) goto <D.46465>; else goto <D.46468>;
        <D.46468>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 <= 9) goto <D.46465>; else goto <D.46469>;
        <D.46469>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 <= 9) goto <D.46465>; else goto <D.46464>;
        <D.46465>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        D.46113 = *D.46112;
        if (D.46113 == 0B) goto <D.46470>; else goto <D.46464>;
        <D.46470>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46111 = D.46048->data.op[1].many_blocks;
        D.46112 = D.46111 + 8;
        *D.46112 = falsebb;
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        goto <D.46466>;
        <D.46464>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 == 0B) goto <D.46471>; else goto <D.46473>;
        <D.46473>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 442) goto <D.46474>; else goto <D.46472>;
        <D.46474>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        if (D.46105 != 759) goto <D.46475>; else goto <D.46472>;
        <D.46475>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46106 = D.46105 + 64985;
        if (D.46106 > 9) goto <D.46476>; else goto <D.46472>;
        <D.46476>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46108 = D.46105 + 64878;
        if (D.46108 > 9) goto <D.46477>; else goto <D.46472>;
        <D.46477>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46105 = D.46048->opcode;
        D.46110 = D.46105 + 64888;
        if (D.46110 > 9) goto <D.46471>; else goto <D.46472>;
        <D.46471>:
        D.46047 = cfg->cbb;
        mono_link_bblock (cfg, D.46047, falsebb);
        <D.46472>:
        <D.46466>:
        D.46047 = cfg->cbb;
        D.46047->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.46478>;
        <D.46458>:
        D.46047 = cfg->cbb;
        D.46047->extended = 1;
        <D.46478>:
        <D.46450>:
      }
      goto <D.46479>;
      <D.46415>:
      D.46270 = klass->cast_class;
      D.46480 = D.46270->flags;
      D.46481 = D.46480 & 32;
      if (D.46481 != 0) goto <D.46482>; else goto <D.46483>;
      <D.46482>:
      D.46270 = klass->cast_class;
      mini_emit_iface_class_cast (cfg, eclass_reg, D.46270, false_bb, is_null_bb);
      goto <D.46484>;
      <D.46483>:
      D.46171 = klass->rank;
      if (D.46171 == 1) goto <D.46485>; else goto <D.46486>;
      <D.46485>:
      D.46487 = klass->byval_arg.type;
      if (D.46487 == 29) goto <D.46488>; else goto <D.46489>;
      <D.46488>:
      {
        int bounds_reg;

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

          D.46036 = cfg->mempool;
          inst = mono_mempool_alloc (D.46036, 80);
          inst->data.op[1].const_val = 0;
          D.46491 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.46491;
          inst->prev = 0B;
          D.46492 = inst->prev;
          inst->next = D.46492;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.46493 = inst->sreg3;
          inst->sreg2 = D.46493;
          D.46494 = inst->sreg2;
          inst->sreg1 = D.46494;
          D.46043 = cfg->ip;
          inst->cil_code = D.46043;
          inst->dreg = bounds_reg;
          inst->sreg1 = obj_reg;
          inst->data.op[0].const_val = 16;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46495>; else goto <D.46496>;
          <D.46495>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = inst;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          inst->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          goto <D.46497>;
          <D.46496>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46497>:
        }
        {
          struct MonoInst * inst;

          D.46036 = cfg->mempool;
          inst = mono_mempool_alloc (D.46036, 80);
          inst->data.op[1].const_val = 0;
          D.46498 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.46498;
          inst->prev = 0B;
          D.46499 = inst->prev;
          inst->next = D.46499;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.46500 = inst->sreg3;
          inst->sreg2 = D.46500;
          D.46501 = inst->sreg2;
          inst->sreg1 = D.46501;
          D.46043 = cfg->ip;
          inst->cil_code = D.46043;
          inst->dreg = -1;
          inst->sreg1 = bounds_reg;
          inst->data.op[1].const_val = 0;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46502>; else goto <D.46503>;
          <D.46502>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = inst;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          inst->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          goto <D.46504>;
          <D.46503>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = inst;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46504>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.46036 = cfg->mempool;
          ins = mono_mempool_alloc (D.46036, 80);
          ins->data.op[1].const_val = 0;
          D.46505 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.46505;
          ins->prev = 0B;
          D.46506 = ins->prev;
          ins->next = D.46506;
          ins->opcode = 556;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.46507 = ins->sreg3;
          ins->sreg2 = D.46507;
          D.46508 = ins->sreg2;
          ins->sreg1 = D.46508;
          D.46043 = cfg->ip;
          ins->cil_code = D.46043;
          if (0 != 0) goto <D.46509>; else goto <D.46510>;
          <D.46509>:
          D.46036 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.46036, 296);
          D.46053 = cfg->num_bblocks;
          D.46511 = D.46053;
          D.46512 = D.46511 + 1;
          cfg->num_bblocks = D.46512;
          D.46513 = (int) D.46511;
          falsebb->block_num = D.46513;
          ins->data.op[0].target_block = false_bb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, false_bb);
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46514>; else goto <D.46515>;
          <D.46514>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = ins;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          ins->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          goto <D.46516>;
          <D.46515>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46516>:
          D.46517 = falsebb->cil_code;
          if (D.46517 != 0B) goto <D.46518>; else goto <D.46519>;
          <D.46518>:
          D.46092 = cfg->cil_offset_to_bb;
          D.46517 = falsebb->cil_code;
          D.46520 = (long int) D.46517;
          D.46094 = cfg->cil_start;
          D.46095 = (long int) D.46094;
          D.46521 = D.46520 - D.46095;
          D.46522 = (long unsigned int) D.46521;
          D.46523 = D.46522 * 8;
          D.46524 = D.46092 + D.46523;
          *D.46524 = falsebb;
          <D.46519>:
          D.46100 = cfg->real_offset;
          falsebb->real_offset = D.46100;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46528>; else goto <D.46525>;
          <D.46528>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 <= 9) goto <D.46526>; else goto <D.46529>;
          <D.46529>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 <= 9) goto <D.46526>; else goto <D.46530>;
          <D.46530>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 <= 9) goto <D.46526>; else goto <D.46525>;
          <D.46526>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          D.46113 = *D.46112;
          if (D.46113 == 0B) goto <D.46531>; else goto <D.46525>;
          <D.46531>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          *D.46112 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          goto <D.46527>;
          <D.46525>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 == 0B) goto <D.46532>; else goto <D.46534>;
          <D.46534>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 442) goto <D.46535>; else goto <D.46533>;
          <D.46535>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 759) goto <D.46536>; else goto <D.46533>;
          <D.46536>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 > 9) goto <D.46537>; else goto <D.46533>;
          <D.46537>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 > 9) goto <D.46538>; else goto <D.46533>;
          <D.46538>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 > 9) goto <D.46532>; else goto <D.46533>;
          <D.46532>:
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          <D.46533>:
          <D.46527>:
          D.46047 = cfg->cbb;
          D.46047->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.46539>;
          <D.46510>:
          D.46036 = cfg->mempool;
          D.46540 = mono_mempool_alloc (D.46036, 16);
          ins->data.op[1].many_blocks = D.46540;
          D.46541 = ins->data.op[1].many_blocks;
          *D.46541 = false_bb;
          D.46541 = ins->data.op[1].many_blocks;
          D.46542 = D.46541 + 8;
          *D.46542 = 0B;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, false_bb);
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46543>; else goto <D.46544>;
          <D.46543>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46048->next = ins;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          ins->prev = D.46048;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          goto <D.46545>;
          <D.46544>:
          D.46047 = cfg->cbb;
          D.46047 = cfg->cbb;
          D.46047->last_ins = ins;
          D.46048 = D.46047->last_ins;
          D.46047->code = D.46048;
          <D.46545>:
          D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.46130 = D.46129 & 34359738368;
          if (D.46130 == 0) goto <D.46546>; else goto <D.46547>;
          <D.46546>:
          D.46036 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.46036, 296);
          D.46053 = cfg->num_bblocks;
          D.46548 = D.46053;
          D.46549 = D.46548 + 1;
          cfg->num_bblocks = D.46549;
          D.46550 = (int) D.46548;
          falsebb->block_num = D.46550;
          D.46541 = ins->data.op[1].many_blocks;
          D.46542 = D.46541 + 8;
          *D.46542 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          D.46517 = falsebb->cil_code;
          if (D.46517 != 0B) goto <D.46551>; else goto <D.46552>;
          <D.46551>:
          D.46092 = cfg->cil_offset_to_bb;
          D.46517 = falsebb->cil_code;
          D.46520 = (long int) D.46517;
          D.46094 = cfg->cil_start;
          D.46095 = (long int) D.46094;
          D.46521 = D.46520 - D.46095;
          D.46522 = (long unsigned int) D.46521;
          D.46523 = D.46522 * 8;
          D.46524 = D.46092 + D.46523;
          *D.46524 = falsebb;
          <D.46552>:
          D.46100 = cfg->real_offset;
          falsebb->real_offset = D.46100;
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 != 0B) goto <D.46556>; else goto <D.46553>;
          <D.46556>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 <= 9) goto <D.46554>; else goto <D.46557>;
          <D.46557>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 <= 9) goto <D.46554>; else goto <D.46558>;
          <D.46558>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 <= 9) goto <D.46554>; else goto <D.46553>;
          <D.46554>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          D.46113 = *D.46112;
          if (D.46113 == 0B) goto <D.46559>; else goto <D.46553>;
          <D.46559>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46111 = D.46048->data.op[1].many_blocks;
          D.46112 = D.46111 + 8;
          *D.46112 = falsebb;
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          goto <D.46555>;
          <D.46553>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          if (D.46048 == 0B) goto <D.46560>; else goto <D.46562>;
          <D.46562>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 442) goto <D.46563>; else goto <D.46561>;
          <D.46563>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          if (D.46105 != 759) goto <D.46564>; else goto <D.46561>;
          <D.46564>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46106 = D.46105 + 64985;
          if (D.46106 > 9) goto <D.46565>; else goto <D.46561>;
          <D.46565>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46108 = D.46105 + 64878;
          if (D.46108 > 9) goto <D.46566>; else goto <D.46561>;
          <D.46566>:
          D.46047 = cfg->cbb;
          D.46048 = D.46047->last_ins;
          D.46105 = D.46048->opcode;
          D.46110 = D.46105 + 64888;
          if (D.46110 > 9) goto <D.46560>; else goto <D.46561>;
          <D.46560>:
          D.46047 = cfg->cbb;
          mono_link_bblock (cfg, D.46047, falsebb);
          <D.46561>:
          <D.46555>:
          D.46047 = cfg->cbb;
          D.46047->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.46567>;
          <D.46547>:
          D.46047 = cfg->cbb;
          D.46047->extended = 1;
          <D.46567>:
          <D.46539>:
        }
      }
      <D.46489>:
      <D.46486>:
      D.46270 = klass->cast_class;
      mini_emit_isninst_cast (cfg, eclass_reg, D.46270, false_bb, is_null_bb);
      <D.46484>:
      <D.46479>:
      <D.46413>:
      <D.46347>:
    }
    goto <D.46568>;
    <D.46173>:
    D.46569 = mono_class_is_nullable (klass);
    if (D.46569 != 0) goto <D.46570>; else goto <D.46571>;
    <D.46570>:
    D.46164 = context_used != 0;
    D.46165 = (long int) D.46164;
    D.46166 = __builtin_expect (D.46165, 0);
    if (D.46166 != 0) goto <D.46572>; else goto <D.46573>;
    <D.46572>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4130, "!context_used");
    <D.46573>:
    {
      struct MonoInst * inst;

      D.46036 = cfg->mempool;
      inst = mono_mempool_alloc (D.46036, 80);
      inst->data.op[1].const_val = 0;
      D.46574 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46574;
      inst->prev = 0B;
      D.46575 = inst->prev;
      inst->next = D.46575;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46576 = inst->sreg3;
      inst->sreg2 = D.46576;
      D.46577 = inst->sreg2;
      inst->sreg1 = D.46577;
      D.46043 = cfg->ip;
      inst->cil_code = D.46043;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46578>; else goto <D.46579>;
      <D.46578>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = inst;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      inst->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      goto <D.46580>;
      <D.46579>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46580>:
    }
    D.46270 = klass->cast_class;
    mini_emit_isninst_cast (cfg, klass_reg, D.46270, false_bb, is_null_bb);
    goto <D.46581>;
    <D.46571>:
    D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.46584 = D.46129 & 274877906944;
    if (D.46584 == 0) goto <D.46585>; else goto <D.46582>;
    <D.46585>:
    D.46586 = cfg->opt;
    D.46587 = D.46586 & 512;
    if (D.46587 == 0) goto <D.46588>; else goto <D.46582>;
    <D.46588>:
    D.46160 = klass->flags;
    D.46589 = D.46160 & 256;
    if (D.46589 != 0) goto <D.46590>; else goto <D.46582>;
    <D.46590>:
    D.46164 = context_used != 0;
    D.46165 = (long int) D.46164;
    D.46166 = __builtin_expect (D.46165, 0);
    if (D.46166 != 0) goto <D.46591>; else goto <D.46592>;
    <D.46591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4136, "!context_used");
    <D.46592>:
    if (0 != 0) goto <D.46593>; else goto <D.46594>;
    <D.46593>:
    {
      struct MonoVTable * vt;

      D.46595 = cfg->domain;
      vt = mono_class_vtable (D.46595, klass);
      if (vt == 0B) goto <D.46596>; else goto <D.46597>;
      <D.46596>:
      mono_cfg_set_exception (cfg, 7);
      cfg->exception_ptr = klass;
      D.46052 = 0B;
      return D.46052;
      <D.46597>:
      {
        struct MonoInst * inst;

        D.46036 = cfg->mempool;
        inst = mono_mempool_alloc (D.46036, 80);
        inst->data.op[1].const_val = 0;
        D.46598 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.46598;
        inst->prev = 0B;
        D.46599 = inst->prev;
        inst->next = D.46599;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.46600 = inst->sreg3;
        inst->sreg2 = D.46600;
        D.46601 = inst->sreg2;
        inst->sreg1 = D.46601;
        D.46043 = cfg->ip;
        inst->cil_code = D.46043;
        inst->dreg = -1;
        inst->sreg1 = vtable_reg;
        vt.432 = (long int) vt;
        inst->data.op[1].const_val = vt.432;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        if (D.46048 != 0B) goto <D.46603>; else goto <D.46604>;
        <D.46603>:
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        D.46048->next = inst;
        D.46047 = cfg->cbb;
        D.46048 = D.46047->last_ins;
        inst->prev = D.46048;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        goto <D.46605>;
        <D.46604>:
        D.46047 = cfg->cbb;
        D.46047 = cfg->cbb;
        D.46047->last_ins = inst;
        D.46048 = D.46047->last_ins;
        D.46047->code = D.46048;
        <D.46605>:
      }
    }
    goto <D.46606>;
    <D.46594>:
    {
      struct MonoInst * inst;

      D.46036 = cfg->mempool;
      inst = mono_mempool_alloc (D.46036, 80);
      inst->data.op[1].const_val = 0;
      D.46607 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46607;
      inst->prev = 0B;
      D.46608 = inst->prev;
      inst->next = D.46608;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46609 = inst->sreg3;
      inst->sreg2 = D.46609;
      D.46610 = inst->sreg2;
      inst->sreg1 = D.46610;
      D.46043 = cfg->ip;
      inst->cil_code = D.46043;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46611>; else goto <D.46612>;
      <D.46611>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = inst;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      inst->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      goto <D.46613>;
      <D.46612>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46613>:
    }
    {
      struct MonoInst * inst;

      D.46036 = cfg->mempool;
      inst = mono_mempool_alloc (D.46036, 80);
      inst->data.op[1].const_val = 0;
      D.46614 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46614;
      inst->prev = 0B;
      D.46615 = inst->prev;
      inst->next = D.46615;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46616 = inst->sreg3;
      inst->sreg2 = D.46616;
      D.46617 = inst->sreg2;
      inst->sreg1 = D.46617;
      D.46043 = cfg->ip;
      inst->cil_code = D.46043;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      klass.433 = (long int) klass;
      inst->data.op[1].const_val = klass.433;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46619>; else goto <D.46620>;
      <D.46619>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = inst;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      inst->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      goto <D.46621>;
      <D.46620>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46621>:
    }
    <D.46606>:
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46036 = cfg->mempool;
      ins = mono_mempool_alloc (D.46036, 80);
      ins->data.op[1].const_val = 0;
      D.46622 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46622;
      ins->prev = 0B;
      D.46623 = ins->prev;
      ins->next = D.46623;
      ins->opcode = 556;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46624 = ins->sreg3;
      ins->sreg2 = D.46624;
      D.46625 = ins->sreg2;
      ins->sreg1 = D.46625;
      D.46043 = cfg->ip;
      ins->cil_code = D.46043;
      if (0 != 0) goto <D.46626>; else goto <D.46627>;
      <D.46626>:
      D.46036 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46036, 296);
      D.46053 = cfg->num_bblocks;
      D.46628 = D.46053;
      D.46629 = D.46628 + 1;
      cfg->num_bblocks = D.46629;
      D.46630 = (int) D.46628;
      falsebb->block_num = D.46630;
      ins->data.op[0].target_block = false_bb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, false_bb);
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46631>; else goto <D.46632>;
      <D.46631>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = ins;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      ins->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      goto <D.46633>;
      <D.46632>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46633>:
      D.46634 = falsebb->cil_code;
      if (D.46634 != 0B) goto <D.46635>; else goto <D.46636>;
      <D.46635>:
      D.46092 = cfg->cil_offset_to_bb;
      D.46634 = falsebb->cil_code;
      D.46637 = (long int) D.46634;
      D.46094 = cfg->cil_start;
      D.46095 = (long int) D.46094;
      D.46638 = D.46637 - D.46095;
      D.46639 = (long unsigned int) D.46638;
      D.46640 = D.46639 * 8;
      D.46641 = D.46092 + D.46640;
      *D.46641 = falsebb;
      <D.46636>:
      D.46100 = cfg->real_offset;
      falsebb->real_offset = D.46100;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46645>; else goto <D.46642>;
      <D.46645>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 <= 9) goto <D.46643>; else goto <D.46646>;
      <D.46646>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 <= 9) goto <D.46643>; else goto <D.46647>;
      <D.46647>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 <= 9) goto <D.46643>; else goto <D.46642>;
      <D.46643>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      D.46113 = *D.46112;
      if (D.46113 == 0B) goto <D.46648>; else goto <D.46642>;
      <D.46648>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      *D.46112 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      goto <D.46644>;
      <D.46642>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 == 0B) goto <D.46649>; else goto <D.46651>;
      <D.46651>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 442) goto <D.46652>; else goto <D.46650>;
      <D.46652>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 759) goto <D.46653>; else goto <D.46650>;
      <D.46653>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 > 9) goto <D.46654>; else goto <D.46650>;
      <D.46654>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 > 9) goto <D.46655>; else goto <D.46650>;
      <D.46655>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 > 9) goto <D.46649>; else goto <D.46650>;
      <D.46649>:
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      <D.46650>:
      <D.46644>:
      D.46047 = cfg->cbb;
      D.46047->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46656>;
      <D.46627>:
      D.46036 = cfg->mempool;
      D.46657 = mono_mempool_alloc (D.46036, 16);
      ins->data.op[1].many_blocks = D.46657;
      D.46658 = ins->data.op[1].many_blocks;
      *D.46658 = false_bb;
      D.46658 = ins->data.op[1].many_blocks;
      D.46659 = D.46658 + 8;
      *D.46659 = 0B;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, false_bb);
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46660>; else goto <D.46661>;
      <D.46660>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = ins;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      ins->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      goto <D.46662>;
      <D.46661>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46662>:
      D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46130 = D.46129 & 34359738368;
      if (D.46130 == 0) goto <D.46663>; else goto <D.46664>;
      <D.46663>:
      D.46036 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46036, 296);
      D.46053 = cfg->num_bblocks;
      D.46665 = D.46053;
      D.46666 = D.46665 + 1;
      cfg->num_bblocks = D.46666;
      D.46667 = (int) D.46665;
      falsebb->block_num = D.46667;
      D.46658 = ins->data.op[1].many_blocks;
      D.46659 = D.46658 + 8;
      *D.46659 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      D.46634 = falsebb->cil_code;
      if (D.46634 != 0B) goto <D.46668>; else goto <D.46669>;
      <D.46668>:
      D.46092 = cfg->cil_offset_to_bb;
      D.46634 = falsebb->cil_code;
      D.46637 = (long int) D.46634;
      D.46094 = cfg->cil_start;
      D.46095 = (long int) D.46094;
      D.46638 = D.46637 - D.46095;
      D.46639 = (long unsigned int) D.46638;
      D.46640 = D.46639 * 8;
      D.46641 = D.46092 + D.46640;
      *D.46641 = falsebb;
      <D.46669>:
      D.46100 = cfg->real_offset;
      falsebb->real_offset = D.46100;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46673>; else goto <D.46670>;
      <D.46673>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 <= 9) goto <D.46671>; else goto <D.46674>;
      <D.46674>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 <= 9) goto <D.46671>; else goto <D.46675>;
      <D.46675>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 <= 9) goto <D.46671>; else goto <D.46670>;
      <D.46671>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      D.46113 = *D.46112;
      if (D.46113 == 0B) goto <D.46676>; else goto <D.46670>;
      <D.46676>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      *D.46112 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      goto <D.46672>;
      <D.46670>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 == 0B) goto <D.46677>; else goto <D.46679>;
      <D.46679>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 442) goto <D.46680>; else goto <D.46678>;
      <D.46680>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 759) goto <D.46681>; else goto <D.46678>;
      <D.46681>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 > 9) goto <D.46682>; else goto <D.46678>;
      <D.46682>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 > 9) goto <D.46683>; else goto <D.46678>;
      <D.46683>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 > 9) goto <D.46677>; else goto <D.46678>;
      <D.46677>:
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      <D.46678>:
      <D.46672>:
      D.46047 = cfg->cbb;
      D.46047->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46684>;
      <D.46664>:
      D.46047 = cfg->cbb;
      D.46047->extended = 1;
      <D.46684>:
      <D.46656>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46036 = cfg->mempool;
      ins = mono_mempool_alloc (D.46036, 80);
      ins->data.op[1].const_val = 0;
      D.46685 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46685;
      ins->prev = 0B;
      D.46686 = ins->prev;
      ins->next = D.46686;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46687 = ins->sreg3;
      ins->sreg2 = D.46687;
      D.46688 = ins->sreg2;
      ins->sreg1 = D.46688;
      D.46043 = cfg->ip;
      ins->cil_code = D.46043;
      if (1 != 0) goto <D.46689>; else goto <D.46690>;
      <D.46689>:
      D.46036 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46036, 296);
      D.46053 = cfg->num_bblocks;
      D.46691 = D.46053;
      D.46692 = D.46691 + 1;
      cfg->num_bblocks = D.46692;
      D.46693 = (int) D.46691;
      falsebb->block_num = D.46693;
      ins->data.op[0].target_block = is_null_bb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, is_null_bb);
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46694>; else goto <D.46695>;
      <D.46694>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = ins;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      ins->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      goto <D.46696>;
      <D.46695>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46696>:
      D.46697 = falsebb->cil_code;
      if (D.46697 != 0B) goto <D.46698>; else goto <D.46699>;
      <D.46698>:
      D.46092 = cfg->cil_offset_to_bb;
      D.46697 = falsebb->cil_code;
      D.46700 = (long int) D.46697;
      D.46094 = cfg->cil_start;
      D.46095 = (long int) D.46094;
      D.46701 = D.46700 - D.46095;
      D.46702 = (long unsigned int) D.46701;
      D.46703 = D.46702 * 8;
      D.46704 = D.46092 + D.46703;
      *D.46704 = falsebb;
      <D.46699>:
      D.46100 = cfg->real_offset;
      falsebb->real_offset = D.46100;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46708>; else goto <D.46705>;
      <D.46708>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 <= 9) goto <D.46706>; else goto <D.46709>;
      <D.46709>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 <= 9) goto <D.46706>; else goto <D.46710>;
      <D.46710>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 <= 9) goto <D.46706>; else goto <D.46705>;
      <D.46706>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      D.46113 = *D.46112;
      if (D.46113 == 0B) goto <D.46711>; else goto <D.46705>;
      <D.46711>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      *D.46112 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      goto <D.46707>;
      <D.46705>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 == 0B) goto <D.46712>; else goto <D.46714>;
      <D.46714>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 442) goto <D.46715>; else goto <D.46713>;
      <D.46715>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 759) goto <D.46716>; else goto <D.46713>;
      <D.46716>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 > 9) goto <D.46717>; else goto <D.46713>;
      <D.46717>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 > 9) goto <D.46718>; else goto <D.46713>;
      <D.46718>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 > 9) goto <D.46712>; else goto <D.46713>;
      <D.46712>:
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      <D.46713>:
      <D.46707>:
      D.46047 = cfg->cbb;
      D.46047->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46719>;
      <D.46690>:
      D.46036 = cfg->mempool;
      D.46720 = mono_mempool_alloc (D.46036, 16);
      ins->data.op[1].many_blocks = D.46720;
      D.46721 = ins->data.op[1].many_blocks;
      *D.46721 = is_null_bb;
      D.46721 = ins->data.op[1].many_blocks;
      D.46722 = D.46721 + 8;
      *D.46722 = 0B;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, is_null_bb);
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46723>; else goto <D.46724>;
      <D.46723>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = ins;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      ins->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      goto <D.46725>;
      <D.46724>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = ins;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46725>:
      D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46130 = D.46129 & 34359738368;
      if (D.46130 == 0) goto <D.46726>; else goto <D.46727>;
      <D.46726>:
      D.46036 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46036, 296);
      D.46053 = cfg->num_bblocks;
      D.46728 = D.46053;
      D.46729 = D.46728 + 1;
      cfg->num_bblocks = D.46729;
      D.46730 = (int) D.46728;
      falsebb->block_num = D.46730;
      D.46721 = ins->data.op[1].many_blocks;
      D.46722 = D.46721 + 8;
      *D.46722 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      D.46697 = falsebb->cil_code;
      if (D.46697 != 0B) goto <D.46731>; else goto <D.46732>;
      <D.46731>:
      D.46092 = cfg->cil_offset_to_bb;
      D.46697 = falsebb->cil_code;
      D.46700 = (long int) D.46697;
      D.46094 = cfg->cil_start;
      D.46095 = (long int) D.46094;
      D.46701 = D.46700 - D.46095;
      D.46702 = (long unsigned int) D.46701;
      D.46703 = D.46702 * 8;
      D.46704 = D.46092 + D.46703;
      *D.46704 = falsebb;
      <D.46732>:
      D.46100 = cfg->real_offset;
      falsebb->real_offset = D.46100;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46736>; else goto <D.46733>;
      <D.46736>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 <= 9) goto <D.46734>; else goto <D.46737>;
      <D.46737>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 <= 9) goto <D.46734>; else goto <D.46738>;
      <D.46738>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 <= 9) goto <D.46734>; else goto <D.46733>;
      <D.46734>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      D.46113 = *D.46112;
      if (D.46113 == 0B) goto <D.46739>; else goto <D.46733>;
      <D.46739>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46111 = D.46048->data.op[1].many_blocks;
      D.46112 = D.46111 + 8;
      *D.46112 = falsebb;
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      goto <D.46735>;
      <D.46733>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 == 0B) goto <D.46740>; else goto <D.46742>;
      <D.46742>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 442) goto <D.46743>; else goto <D.46741>;
      <D.46743>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      if (D.46105 != 759) goto <D.46744>; else goto <D.46741>;
      <D.46744>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46106 = D.46105 + 64985;
      if (D.46106 > 9) goto <D.46745>; else goto <D.46741>;
      <D.46745>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46108 = D.46105 + 64878;
      if (D.46108 > 9) goto <D.46746>; else goto <D.46741>;
      <D.46746>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46105 = D.46048->opcode;
      D.46110 = D.46105 + 64888;
      if (D.46110 > 9) goto <D.46740>; else goto <D.46741>;
      <D.46740>:
      D.46047 = cfg->cbb;
      mono_link_bblock (cfg, D.46047, falsebb);
      <D.46741>:
      <D.46735>:
      D.46047 = cfg->cbb;
      D.46047->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46747>;
      <D.46727>:
      D.46047 = cfg->cbb;
      D.46047->extended = 1;
      <D.46747>:
      <D.46719>:
    }
    goto <D.46583>;
    <D.46582>:
    {
      struct MonoInst * inst;

      D.46036 = cfg->mempool;
      inst = mono_mempool_alloc (D.46036, 80);
      inst->data.op[1].const_val = 0;
      D.46748 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46748;
      inst->prev = 0B;
      D.46749 = inst->prev;
      inst->next = D.46749;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46750 = inst->sreg3;
      inst->sreg2 = D.46750;
      D.46751 = inst->sreg2;
      inst->sreg1 = D.46751;
      D.46043 = cfg->ip;
      inst->cil_code = D.46043;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      if (D.46048 != 0B) goto <D.46752>; else goto <D.46753>;
      <D.46752>:
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      D.46048->next = inst;
      D.46047 = cfg->cbb;
      D.46048 = D.46047->last_ins;
      inst->prev = D.46048;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      goto <D.46754>;
      <D.46753>:
      D.46047 = cfg->cbb;
      D.46047 = cfg->cbb;
      D.46047->last_ins = inst;
      D.46048 = D.46047->last_ins;
      D.46047->code = D.46048;
      <D.46754>:
    }
    mini_emit_isninst_cast_inst (cfg, klass_reg, klass, klass_inst, false_bb, is_null_bb);
    <D.46583>:
    <D.46581>:
    <D.46568>:
  }
  <D.46169>:
  D.46755 = false_bb->cil_code;
  if (D.46755 != 0B) goto <D.46756>; else goto <D.46757>;
  <D.46756>:
  D.46092 = cfg->cil_offset_to_bb;
  D.46755 = false_bb->cil_code;
  D.46758 = (long int) D.46755;
  D.46094 = cfg->cil_start;
  D.46095 = (long int) D.46094;
  D.46759 = D.46758 - D.46095;
  D.46760 = (long unsigned int) D.46759;
  D.46761 = D.46760 * 8;
  D.46762 = D.46092 + D.46761;
  *D.46762 = false_bb;
  <D.46757>:
  D.46100 = cfg->real_offset;
  false_bb->real_offset = D.46100;
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 != 0B) goto <D.46766>; else goto <D.46763>;
  <D.46766>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 <= 9) goto <D.46764>; else goto <D.46767>;
  <D.46767>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 <= 9) goto <D.46764>; else goto <D.46768>;
  <D.46768>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 <= 9) goto <D.46764>; else goto <D.46763>;
  <D.46764>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  D.46113 = *D.46112;
  if (D.46113 == 0B) goto <D.46769>; else goto <D.46763>;
  <D.46769>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  *D.46112 = false_bb;
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, false_bb);
  goto <D.46765>;
  <D.46763>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 == 0B) goto <D.46770>; else goto <D.46772>;
  <D.46772>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 442) goto <D.46773>; else goto <D.46771>;
  <D.46773>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 759) goto <D.46774>; else goto <D.46771>;
  <D.46774>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 > 9) goto <D.46775>; else goto <D.46771>;
  <D.46775>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 > 9) goto <D.46776>; else goto <D.46771>;
  <D.46776>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 > 9) goto <D.46770>; else goto <D.46771>;
  <D.46770>:
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, false_bb);
  <D.46771>:
  <D.46765>:
  D.46047 = cfg->cbb;
  D.46047->next_bb = false_bb;
  cfg->cbb = false_bb;
  {
    struct MonoInst * inst;

    D.46036 = cfg->mempool;
    inst = mono_mempool_alloc (D.46036, 80);
    inst->data.op[1].const_val = 0;
    D.46777 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46777;
    inst->prev = 0B;
    D.46778 = inst->prev;
    inst->next = D.46778;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46779 = inst->sreg3;
    inst->sreg2 = D.46779;
    D.46780 = inst->sreg2;
    inst->sreg1 = D.46780;
    D.46043 = cfg->ip;
    inst->cil_code = D.46043;
    inst->dreg = res_reg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46781>; else goto <D.46782>;
    <D.46781>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = inst;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    inst->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    goto <D.46783>;
    <D.46782>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = inst;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46783>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.46036 = cfg->mempool;
    ins = mono_mempool_alloc (D.46036, 80);
    ins->data.op[1].const_val = 0;
    D.46784 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.46784;
    ins->prev = 0B;
    D.46785 = ins->prev;
    ins->next = D.46785;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.46786 = ins->sreg3;
    ins->sreg2 = D.46786;
    D.46787 = ins->sreg2;
    ins->sreg1 = D.46787;
    D.46043 = cfg->ip;
    ins->cil_code = D.46043;
    if (1 != 0) goto <D.46788>; else goto <D.46789>;
    <D.46788>:
    D.46036 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46036, 296);
    D.46053 = cfg->num_bblocks;
    D.46790 = D.46053;
    D.46791 = D.46790 + 1;
    cfg->num_bblocks = D.46791;
    D.46792 = (int) D.46790;
    falsebb->block_num = D.46792;
    ins->data.op[0].target_block = end_bb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, end_bb);
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46793>; else goto <D.46794>;
    <D.46793>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = ins;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    ins->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    goto <D.46795>;
    <D.46794>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46795>:
    D.46796 = falsebb->cil_code;
    if (D.46796 != 0B) goto <D.46797>; else goto <D.46798>;
    <D.46797>:
    D.46092 = cfg->cil_offset_to_bb;
    D.46796 = falsebb->cil_code;
    D.46799 = (long int) D.46796;
    D.46094 = cfg->cil_start;
    D.46095 = (long int) D.46094;
    D.46800 = D.46799 - D.46095;
    D.46801 = (long unsigned int) D.46800;
    D.46802 = D.46801 * 8;
    D.46803 = D.46092 + D.46802;
    *D.46803 = falsebb;
    <D.46798>:
    D.46100 = cfg->real_offset;
    falsebb->real_offset = D.46100;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46807>; else goto <D.46804>;
    <D.46807>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 <= 9) goto <D.46805>; else goto <D.46808>;
    <D.46808>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 <= 9) goto <D.46805>; else goto <D.46809>;
    <D.46809>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 <= 9) goto <D.46805>; else goto <D.46804>;
    <D.46805>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    D.46113 = *D.46112;
    if (D.46113 == 0B) goto <D.46810>; else goto <D.46804>;
    <D.46810>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    *D.46112 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    goto <D.46806>;
    <D.46804>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 == 0B) goto <D.46811>; else goto <D.46813>;
    <D.46813>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 442) goto <D.46814>; else goto <D.46812>;
    <D.46814>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 759) goto <D.46815>; else goto <D.46812>;
    <D.46815>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 > 9) goto <D.46816>; else goto <D.46812>;
    <D.46816>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 > 9) goto <D.46817>; else goto <D.46812>;
    <D.46817>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 > 9) goto <D.46811>; else goto <D.46812>;
    <D.46811>:
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    <D.46812>:
    <D.46806>:
    D.46047 = cfg->cbb;
    D.46047->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46818>;
    <D.46789>:
    D.46036 = cfg->mempool;
    D.46819 = mono_mempool_alloc (D.46036, 16);
    ins->data.op[1].many_blocks = D.46819;
    D.46820 = ins->data.op[1].many_blocks;
    *D.46820 = end_bb;
    D.46820 = ins->data.op[1].many_blocks;
    D.46821 = D.46820 + 8;
    *D.46821 = 0B;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, end_bb);
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46822>; else goto <D.46823>;
    <D.46822>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46048->next = ins;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    ins->prev = D.46048;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    goto <D.46824>;
    <D.46823>:
    D.46047 = cfg->cbb;
    D.46047 = cfg->cbb;
    D.46047->last_ins = ins;
    D.46048 = D.46047->last_ins;
    D.46047->code = D.46048;
    <D.46824>:
    D.46129 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.46130 = D.46129 & 34359738368;
    if (D.46130 == 0) goto <D.46825>; else goto <D.46826>;
    <D.46825>:
    D.46036 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46036, 296);
    D.46053 = cfg->num_bblocks;
    D.46827 = D.46053;
    D.46828 = D.46827 + 1;
    cfg->num_bblocks = D.46828;
    D.46829 = (int) D.46827;
    falsebb->block_num = D.46829;
    D.46820 = ins->data.op[1].many_blocks;
    D.46821 = D.46820 + 8;
    *D.46821 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    D.46796 = falsebb->cil_code;
    if (D.46796 != 0B) goto <D.46830>; else goto <D.46831>;
    <D.46830>:
    D.46092 = cfg->cil_offset_to_bb;
    D.46796 = falsebb->cil_code;
    D.46799 = (long int) D.46796;
    D.46094 = cfg->cil_start;
    D.46095 = (long int) D.46094;
    D.46800 = D.46799 - D.46095;
    D.46801 = (long unsigned int) D.46800;
    D.46802 = D.46801 * 8;
    D.46803 = D.46092 + D.46802;
    *D.46803 = falsebb;
    <D.46831>:
    D.46100 = cfg->real_offset;
    falsebb->real_offset = D.46100;
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 != 0B) goto <D.46835>; else goto <D.46832>;
    <D.46835>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 <= 9) goto <D.46833>; else goto <D.46836>;
    <D.46836>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 <= 9) goto <D.46833>; else goto <D.46837>;
    <D.46837>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 <= 9) goto <D.46833>; else goto <D.46832>;
    <D.46833>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    D.46113 = *D.46112;
    if (D.46113 == 0B) goto <D.46838>; else goto <D.46832>;
    <D.46838>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46111 = D.46048->data.op[1].many_blocks;
    D.46112 = D.46111 + 8;
    *D.46112 = falsebb;
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    goto <D.46834>;
    <D.46832>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    if (D.46048 == 0B) goto <D.46839>; else goto <D.46841>;
    <D.46841>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 442) goto <D.46842>; else goto <D.46840>;
    <D.46842>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    if (D.46105 != 759) goto <D.46843>; else goto <D.46840>;
    <D.46843>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46106 = D.46105 + 64985;
    if (D.46106 > 9) goto <D.46844>; else goto <D.46840>;
    <D.46844>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46108 = D.46105 + 64878;
    if (D.46108 > 9) goto <D.46845>; else goto <D.46840>;
    <D.46845>:
    D.46047 = cfg->cbb;
    D.46048 = D.46047->last_ins;
    D.46105 = D.46048->opcode;
    D.46110 = D.46105 + 64888;
    if (D.46110 > 9) goto <D.46839>; else goto <D.46840>;
    <D.46839>:
    D.46047 = cfg->cbb;
    mono_link_bblock (cfg, D.46047, falsebb);
    <D.46840>:
    <D.46834>:
    D.46047 = cfg->cbb;
    D.46047->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46846>;
    <D.46826>:
    D.46047 = cfg->cbb;
    D.46047->extended = 1;
    <D.46846>:
    <D.46818>:
  }
  D.46847 = is_null_bb->cil_code;
  if (D.46847 != 0B) goto <D.46848>; else goto <D.46849>;
  <D.46848>:
  D.46092 = cfg->cil_offset_to_bb;
  D.46847 = is_null_bb->cil_code;
  D.46850 = (long int) D.46847;
  D.46094 = cfg->cil_start;
  D.46095 = (long int) D.46094;
  D.46851 = D.46850 - D.46095;
  D.46852 = (long unsigned int) D.46851;
  D.46853 = D.46852 * 8;
  D.46854 = D.46092 + D.46853;
  *D.46854 = is_null_bb;
  <D.46849>:
  D.46100 = cfg->real_offset;
  is_null_bb->real_offset = D.46100;
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 != 0B) goto <D.46858>; else goto <D.46855>;
  <D.46858>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 <= 9) goto <D.46856>; else goto <D.46859>;
  <D.46859>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 <= 9) goto <D.46856>; else goto <D.46860>;
  <D.46860>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 <= 9) goto <D.46856>; else goto <D.46855>;
  <D.46856>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  D.46113 = *D.46112;
  if (D.46113 == 0B) goto <D.46861>; else goto <D.46855>;
  <D.46861>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  *D.46112 = is_null_bb;
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, is_null_bb);
  goto <D.46857>;
  <D.46855>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 == 0B) goto <D.46862>; else goto <D.46864>;
  <D.46864>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 442) goto <D.46865>; else goto <D.46863>;
  <D.46865>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 759) goto <D.46866>; else goto <D.46863>;
  <D.46866>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 > 9) goto <D.46867>; else goto <D.46863>;
  <D.46867>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 > 9) goto <D.46868>; else goto <D.46863>;
  <D.46868>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 > 9) goto <D.46862>; else goto <D.46863>;
  <D.46862>:
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, is_null_bb);
  <D.46863>:
  <D.46857>:
  D.46047 = cfg->cbb;
  D.46047->next_bb = is_null_bb;
  cfg->cbb = is_null_bb;
  D.46869 = end_bb->cil_code;
  if (D.46869 != 0B) goto <D.46870>; else goto <D.46871>;
  <D.46870>:
  D.46092 = cfg->cil_offset_to_bb;
  D.46869 = end_bb->cil_code;
  D.46872 = (long int) D.46869;
  D.46094 = cfg->cil_start;
  D.46095 = (long int) D.46094;
  D.46873 = D.46872 - D.46095;
  D.46874 = (long unsigned int) D.46873;
  D.46875 = D.46874 * 8;
  D.46876 = D.46092 + D.46875;
  *D.46876 = end_bb;
  <D.46871>:
  D.46100 = cfg->real_offset;
  end_bb->real_offset = D.46100;
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 != 0B) goto <D.46880>; else goto <D.46877>;
  <D.46880>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 <= 9) goto <D.46878>; else goto <D.46881>;
  <D.46881>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 <= 9) goto <D.46878>; else goto <D.46882>;
  <D.46882>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 <= 9) goto <D.46878>; else goto <D.46877>;
  <D.46878>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  D.46113 = *D.46112;
  if (D.46113 == 0B) goto <D.46883>; else goto <D.46877>;
  <D.46883>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46111 = D.46048->data.op[1].many_blocks;
  D.46112 = D.46111 + 8;
  *D.46112 = end_bb;
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, end_bb);
  goto <D.46879>;
  <D.46877>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  if (D.46048 == 0B) goto <D.46884>; else goto <D.46886>;
  <D.46886>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 442) goto <D.46887>; else goto <D.46885>;
  <D.46887>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  if (D.46105 != 759) goto <D.46888>; else goto <D.46885>;
  <D.46888>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46106 = D.46105 + 64985;
  if (D.46106 > 9) goto <D.46889>; else goto <D.46885>;
  <D.46889>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46108 = D.46105 + 64878;
  if (D.46108 > 9) goto <D.46890>; else goto <D.46885>;
  <D.46890>:
  D.46047 = cfg->cbb;
  D.46048 = D.46047->last_ins;
  D.46105 = D.46048->opcode;
  D.46110 = D.46105 + 64888;
  if (D.46110 > 9) goto <D.46884>; else goto <D.46885>;
  <D.46884>:
  D.46047 = cfg->cbb;
  mono_link_bblock (cfg, D.46047, end_bb);
  <D.46885>:
  <D.46879>:
  D.46047 = cfg->cbb;
  D.46047->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.46052 = ins;
  return D.46052;
}


mini_emit_iface_cast (struct MonoCompile * cfg, int vtable_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target, struct MonoBasicBlock * true_target)
{
  unsigned int D.46894;
  struct MonoMemPool * D.46895;
  long int D.46896;
  struct MonoInst * D.46897;
  int D.46898;
  int D.46899;
  const unsigned char * D.46900;
  struct MonoBasicBlock * D.46901;
  struct MonoInst * D.46902;
  long int D.46908;
  struct MonoInst * D.46909;
  int D.46910;
  int D.46911;
  unsigned int D.46914;
  unsigned int D.46915;
  unsigned int D.46916;
  int D.46917;
  unsigned char * D.46921;
  struct MonoBasicBlock * * D.46924;
  long int D.46925;
  unsigned char * D.46926;
  long int D.46927;
  long int D.46928;
  long unsigned int D.46929;
  long unsigned int D.46930;
  struct MonoBasicBlock * * D.46931;
  unsigned int D.46932;
  short unsigned int D.46937;
  short unsigned int D.46938;
  short unsigned int D.46940;
  short unsigned int D.46942;
  struct MonoBasicBlock * * D.46943;
  struct MonoBasicBlock * * D.46944;
  struct MonoBasicBlock * D.46945;
  void * D.46955;
  struct MonoBasicBlock * * D.46956;
  struct MonoBasicBlock * * D.46957;
  long unsigned int D.46961;
  long unsigned int D.46962;
  unsigned int D.46965;
  unsigned int D.46966;
  int D.46967;
  long int D.46986;
  struct MonoInst * D.46987;
  int D.46988;
  int D.46989;
  int intf_reg;

  D.46894 = alloc_preg (cfg);
  intf_reg = (int) D.46894;
  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.46895 = cfg->mempool;
    inst = mono_mempool_alloc (D.46895, 80);
    inst->data.op[1].const_val = 0;
    D.46896 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46896;
    inst->prev = 0B;
    D.46897 = inst->prev;
    inst->next = D.46897;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46898 = inst->sreg3;
    inst->sreg2 = D.46898;
    D.46899 = inst->sreg2;
    inst->sreg1 = D.46899;
    D.46900 = cfg->ip;
    inst->cil_code = D.46900;
    inst->dreg = -1;
    inst->sreg1 = intf_reg;
    inst->data.op[1].const_val = 0;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46903>; else goto <D.46904>;
    <D.46903>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46902->next = inst;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    inst->prev = D.46902;
    D.46901 = cfg->cbb;
    D.46901->last_ins = inst;
    goto <D.46905>;
    <D.46904>:
    D.46901 = cfg->cbb;
    D.46901 = cfg->cbb;
    D.46901->last_ins = inst;
    D.46902 = D.46901->last_ins;
    D.46901->code = D.46902;
    <D.46905>:
  }
  if (true_target != 0B) goto <D.46906>; else goto <D.46907>;
  <D.46906>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.46895 = cfg->mempool;
    ins = mono_mempool_alloc (D.46895, 80);
    ins->data.op[1].const_val = 0;
    D.46908 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.46908;
    ins->prev = 0B;
    D.46909 = ins->prev;
    ins->next = D.46909;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.46910 = ins->sreg3;
    ins->sreg2 = D.46910;
    D.46911 = ins->sreg2;
    ins->sreg1 = D.46911;
    D.46900 = cfg->ip;
    ins->cil_code = D.46900;
    if (0 != 0) goto <D.46912>; else goto <D.46913>;
    <D.46912>:
    D.46895 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46895, 296);
    D.46914 = cfg->num_bblocks;
    D.46915 = D.46914;
    D.46916 = D.46915 + 1;
    cfg->num_bblocks = D.46916;
    D.46917 = (int) D.46915;
    falsebb->block_num = D.46917;
    ins->data.op[0].target_block = true_target;
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, true_target);
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46918>; else goto <D.46919>;
    <D.46918>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46902->next = ins;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    ins->prev = D.46902;
    D.46901 = cfg->cbb;
    D.46901->last_ins = ins;
    goto <D.46920>;
    <D.46919>:
    D.46901 = cfg->cbb;
    D.46901 = cfg->cbb;
    D.46901->last_ins = ins;
    D.46902 = D.46901->last_ins;
    D.46901->code = D.46902;
    <D.46920>:
    D.46921 = falsebb->cil_code;
    if (D.46921 != 0B) goto <D.46922>; else goto <D.46923>;
    <D.46922>:
    D.46924 = cfg->cil_offset_to_bb;
    D.46921 = falsebb->cil_code;
    D.46925 = (long int) D.46921;
    D.46926 = cfg->cil_start;
    D.46927 = (long int) D.46926;
    D.46928 = D.46925 - D.46927;
    D.46929 = (long unsigned int) D.46928;
    D.46930 = D.46929 * 8;
    D.46931 = D.46924 + D.46930;
    *D.46931 = falsebb;
    <D.46923>:
    D.46932 = cfg->real_offset;
    falsebb->real_offset = D.46932;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46936>; else goto <D.46933>;
    <D.46936>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46938 = D.46937 + 64985;
    if (D.46938 <= 9) goto <D.46934>; else goto <D.46939>;
    <D.46939>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46940 = D.46937 + 64878;
    if (D.46940 <= 9) goto <D.46934>; else goto <D.46941>;
    <D.46941>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46942 = D.46937 + 64888;
    if (D.46942 <= 9) goto <D.46934>; else goto <D.46933>;
    <D.46934>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46943 = D.46902->data.op[1].many_blocks;
    D.46944 = D.46943 + 8;
    D.46945 = *D.46944;
    if (D.46945 == 0B) goto <D.46946>; else goto <D.46933>;
    <D.46946>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46943 = D.46902->data.op[1].many_blocks;
    D.46944 = D.46943 + 8;
    *D.46944 = falsebb;
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, falsebb);
    goto <D.46935>;
    <D.46933>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 == 0B) goto <D.46947>; else goto <D.46949>;
    <D.46949>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    if (D.46937 != 442) goto <D.46950>; else goto <D.46948>;
    <D.46950>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    if (D.46937 != 759) goto <D.46951>; else goto <D.46948>;
    <D.46951>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46938 = D.46937 + 64985;
    if (D.46938 > 9) goto <D.46952>; else goto <D.46948>;
    <D.46952>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46940 = D.46937 + 64878;
    if (D.46940 > 9) goto <D.46953>; else goto <D.46948>;
    <D.46953>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46942 = D.46937 + 64888;
    if (D.46942 > 9) goto <D.46947>; else goto <D.46948>;
    <D.46947>:
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, falsebb);
    <D.46948>:
    <D.46935>:
    D.46901 = cfg->cbb;
    D.46901->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46954>;
    <D.46913>:
    D.46895 = cfg->mempool;
    D.46955 = mono_mempool_alloc (D.46895, 16);
    ins->data.op[1].many_blocks = D.46955;
    D.46956 = ins->data.op[1].many_blocks;
    *D.46956 = true_target;
    D.46956 = ins->data.op[1].many_blocks;
    D.46957 = D.46956 + 8;
    *D.46957 = 0B;
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, true_target);
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46958>; else goto <D.46959>;
    <D.46958>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46902->next = ins;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    ins->prev = D.46902;
    D.46901 = cfg->cbb;
    D.46901->last_ins = ins;
    goto <D.46960>;
    <D.46959>:
    D.46901 = cfg->cbb;
    D.46901 = cfg->cbb;
    D.46901->last_ins = ins;
    D.46902 = D.46901->last_ins;
    D.46901->code = D.46902;
    <D.46960>:
    D.46961 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.46962 = D.46961 & 34359738368;
    if (D.46962 == 0) goto <D.46963>; else goto <D.46964>;
    <D.46963>:
    D.46895 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.46895, 296);
    D.46914 = cfg->num_bblocks;
    D.46965 = D.46914;
    D.46966 = D.46965 + 1;
    cfg->num_bblocks = D.46966;
    D.46967 = (int) D.46965;
    falsebb->block_num = D.46967;
    D.46956 = ins->data.op[1].many_blocks;
    D.46957 = D.46956 + 8;
    *D.46957 = falsebb;
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, falsebb);
    D.46921 = falsebb->cil_code;
    if (D.46921 != 0B) goto <D.46968>; else goto <D.46969>;
    <D.46968>:
    D.46924 = cfg->cil_offset_to_bb;
    D.46921 = falsebb->cil_code;
    D.46925 = (long int) D.46921;
    D.46926 = cfg->cil_start;
    D.46927 = (long int) D.46926;
    D.46928 = D.46925 - D.46927;
    D.46929 = (long unsigned int) D.46928;
    D.46930 = D.46929 * 8;
    D.46931 = D.46924 + D.46930;
    *D.46931 = falsebb;
    <D.46969>:
    D.46932 = cfg->real_offset;
    falsebb->real_offset = D.46932;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46973>; else goto <D.46970>;
    <D.46973>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46938 = D.46937 + 64985;
    if (D.46938 <= 9) goto <D.46971>; else goto <D.46974>;
    <D.46974>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46940 = D.46937 + 64878;
    if (D.46940 <= 9) goto <D.46971>; else goto <D.46975>;
    <D.46975>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46942 = D.46937 + 64888;
    if (D.46942 <= 9) goto <D.46971>; else goto <D.46970>;
    <D.46971>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46943 = D.46902->data.op[1].many_blocks;
    D.46944 = D.46943 + 8;
    D.46945 = *D.46944;
    if (D.46945 == 0B) goto <D.46976>; else goto <D.46970>;
    <D.46976>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46943 = D.46902->data.op[1].many_blocks;
    D.46944 = D.46943 + 8;
    *D.46944 = falsebb;
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, falsebb);
    goto <D.46972>;
    <D.46970>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 == 0B) goto <D.46977>; else goto <D.46979>;
    <D.46979>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    if (D.46937 != 442) goto <D.46980>; else goto <D.46978>;
    <D.46980>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    if (D.46937 != 759) goto <D.46981>; else goto <D.46978>;
    <D.46981>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46938 = D.46937 + 64985;
    if (D.46938 > 9) goto <D.46982>; else goto <D.46978>;
    <D.46982>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46940 = D.46937 + 64878;
    if (D.46940 > 9) goto <D.46983>; else goto <D.46978>;
    <D.46983>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46937 = D.46902->opcode;
    D.46942 = D.46937 + 64888;
    if (D.46942 > 9) goto <D.46977>; else goto <D.46978>;
    <D.46977>:
    D.46901 = cfg->cbb;
    mono_link_bblock (cfg, D.46901, falsebb);
    <D.46978>:
    <D.46972>:
    D.46901 = cfg->cbb;
    D.46901->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.46984>;
    <D.46964>:
    D.46901 = cfg->cbb;
    D.46901->extended = 1;
    <D.46984>:
    <D.46954>:
  }
  goto <D.46985>;
  <D.46907>:
  {
    struct MonoInst * inst;

    D.46895 = cfg->mempool;
    inst = mono_mempool_alloc (D.46895, 80);
    inst->data.op[1].const_val = 0;
    D.46986 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46986;
    inst->prev = 0B;
    D.46987 = inst->prev;
    inst->next = D.46987;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46988 = inst->sreg3;
    inst->sreg2 = D.46988;
    D.46989 = inst->sreg2;
    inst->sreg1 = D.46989;
    D.46900 = cfg->ip;
    inst->cil_code = D.46900;
    inst->data.op[1].p = "InvalidCastException";
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    if (D.46902 != 0B) goto <D.46990>; else goto <D.46991>;
    <D.46990>:
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    D.46902->next = inst;
    D.46901 = cfg->cbb;
    D.46902 = D.46901->last_ins;
    inst->prev = D.46902;
    D.46901 = cfg->cbb;
    D.46901->last_ins = inst;
    goto <D.46992>;
    <D.46991>:
    D.46901 = cfg->cbb;
    D.46901 = cfg->cbb;
    D.46901->last_ins = inst;
    D.46902 = D.46901->last_ins;
    D.46901->code = D.46902;
    <D.46992>:
  }
  <D.46985>:
}


mini_emit_max_iid_check_vtable (struct MonoCompile * cfg, int vtable_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target)
{
  unsigned int D.46993;
  struct MonoMemPool * D.46994;
  long int D.46995;
  struct MonoInst * D.46996;
  int D.46997;
  int D.46998;
  const unsigned char * D.46999;
  struct MonoBasicBlock * D.47000;
  struct MonoInst * D.47001;
  int max_iid_reg;

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

    D.46994 = cfg->mempool;
    inst = mono_mempool_alloc (D.46994, 80);
    inst->data.op[1].const_val = 0;
    D.46995 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46995;
    inst->prev = 0B;
    D.46996 = inst->prev;
    inst->next = D.46996;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46997 = inst->sreg3;
    inst->sreg2 = D.46997;
    D.46998 = inst->sreg2;
    inst->sreg1 = D.46998;
    D.46999 = cfg->ip;
    inst->cil_code = D.46999;
    inst->dreg = max_iid_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 40;
    D.47000 = cfg->cbb;
    D.47001 = D.47000->last_ins;
    if (D.47001 != 0B) goto <D.47002>; else goto <D.47003>;
    <D.47002>:
    D.47000 = cfg->cbb;
    D.47001 = D.47000->last_ins;
    D.47001->next = inst;
    D.47000 = cfg->cbb;
    D.47001 = D.47000->last_ins;
    inst->prev = D.47001;
    D.47000 = cfg->cbb;
    D.47000->last_ins = inst;
    goto <D.47004>;
    <D.47003>:
    D.47000 = cfg->cbb;
    D.47000 = cfg->cbb;
    D.47000->last_ins = inst;
    D.47001 = D.47000->last_ins;
    D.47000->code = D.47001;
    <D.47004>:
  }
  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.47005;
  long unsigned int D.47006;
  unsigned int D.47009;
  struct MonoMemPool * D.47010;
  long int D.47011;
  struct MonoInst * D.47012;
  guint16 iftmp.434;
  int D.47017;
  int D.47018;
  const unsigned char * D.47019;
  long int D.47022;
  struct MonoInst * D.47023;
  int D.47024;
  int D.47025;
  int D.47026;
  unsigned int D.47028;
  int D.47029;
  struct MonoBasicBlock * D.47030;
  struct MonoInst * D.47031;
  long int D.47035;
  struct MonoInst * D.47036;
  int D.47037;
  int D.47038;
  long int D.47043;
  struct MonoInst * D.47044;
  int D.47045;
  int D.47046;
  short unsigned int D.47047;
  long int D.47048;
  long int D.47054;
  struct MonoInst * D.47055;
  int D.47056;
  int D.47057;
  unsigned int D.47060;
  unsigned int D.47061;
  unsigned int D.47062;
  int D.47063;
  unsigned char * D.47067;
  struct MonoBasicBlock * * D.47070;
  long int D.47071;
  unsigned char * D.47072;
  long int D.47073;
  long int D.47074;
  long unsigned int D.47075;
  long unsigned int D.47076;
  struct MonoBasicBlock * * D.47077;
  unsigned int D.47078;
  short unsigned int D.47083;
  short unsigned int D.47084;
  short unsigned int D.47086;
  short unsigned int D.47088;
  struct MonoBasicBlock * * D.47089;
  struct MonoBasicBlock * * D.47090;
  struct MonoBasicBlock * D.47091;
  void * D.47101;
  struct MonoBasicBlock * * D.47102;
  struct MonoBasicBlock * * D.47103;
  long unsigned int D.47107;
  unsigned int D.47110;
  unsigned int D.47111;
  int D.47112;
  long int D.47131;
  struct MonoInst * D.47132;
  int D.47133;
  int D.47134;

  D.47005 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47006 = D.47005 & 274877906944;
  if (D.47006 != 0) goto <D.47007>; else goto <D.47008>;
  <D.47007>:
  {
    int iid_reg;

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

      D.47010 = cfg->mempool;
      inst = mono_mempool_alloc (D.47010, 80);
      inst->data.op[1].const_val = 0;
      D.47011 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47011;
      inst->prev = 0B;
      D.47012 = inst->prev;
      inst->next = D.47012;
      D.47005 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47006 = D.47005 & 274877906944;
      if (D.47006 != 0) goto <D.47014>; else goto <D.47015>;
      <D.47014>:
      iftmp.434 = 734;
      goto <D.47016>;
      <D.47015>:
      iftmp.434 = 363;
      <D.47016>:
      inst->opcode = iftmp.434;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47017 = inst->sreg3;
      inst->sreg2 = D.47017;
      D.47018 = inst->sreg2;
      inst->sreg1 = D.47018;
      D.47019 = cfg->ip;
      inst->cil_code = D.47019;
      D.47005 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47006 = D.47005 & 274877906944;
      if (D.47006 != 0) goto <D.47020>; else goto <D.47021>;
      <D.47020>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.47010 = cfg->mempool;
        group = mono_mempool_alloc (D.47010, 80);
        group->data.op[1].const_val = 0;
        D.47022 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.47022;
        group->prev = 0B;
        D.47023 = group->prev;
        group->next = D.47023;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.47024 = group->sreg3;
        group->sreg2 = D.47024;
        D.47025 = group->sreg2;
        group->sreg1 = D.47025;
        D.47019 = cfg->ip;
        group->cil_code = D.47019;
        group->data.op[0].src = klass;
        group->data.op[1].src = 23B;
        D.47026 = got_loc->dreg;
        inst->sreg1 = D.47026;
        inst->data.op[1].p = group;
      }
      goto <D.47027>;
      <D.47021>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 23B;
      <D.47027>:
      inst->type = 3;
      D.47028 = alloc_dreg (cfg, 3);
      D.47029 = (int) D.47028;
      inst->dreg = D.47029;
      inst->dreg = iid_reg;
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      if (D.47031 != 0B) goto <D.47032>; else goto <D.47033>;
      <D.47032>:
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      D.47031->next = inst;
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      inst->prev = D.47031;
      D.47030 = cfg->cbb;
      D.47030->last_ins = inst;
      goto <D.47034>;
      <D.47033>:
      D.47030 = cfg->cbb;
      D.47030 = cfg->cbb;
      D.47030->last_ins = inst;
      D.47031 = D.47030->last_ins;
      D.47030->code = D.47031;
      <D.47034>:
    }
    {
      struct MonoInst * inst;

      D.47010 = cfg->mempool;
      inst = mono_mempool_alloc (D.47010, 80);
      inst->data.op[1].const_val = 0;
      D.47035 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47035;
      inst->prev = 0B;
      D.47036 = inst->prev;
      inst->next = D.47036;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47037 = inst->sreg3;
      inst->sreg2 = D.47037;
      D.47038 = inst->sreg2;
      inst->sreg1 = D.47038;
      D.47019 = cfg->ip;
      inst->cil_code = D.47019;
      inst->dreg = -1;
      inst->sreg1 = max_iid_reg;
      inst->sreg2 = iid_reg;
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      if (D.47031 != 0B) goto <D.47039>; else goto <D.47040>;
      <D.47039>:
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      D.47031->next = inst;
      D.47030 = cfg->cbb;
      D.47031 = D.47030->last_ins;
      inst->prev = D.47031;
      D.47030 = cfg->cbb;
      D.47030->last_ins = inst;
      goto <D.47041>;
      <D.47040>:
      D.47030 = cfg->cbb;
      D.47030 = cfg->cbb;
      D.47030->last_ins = inst;
      D.47031 = D.47030->last_ins;
      D.47030->code = D.47031;
      <D.47041>:
    }
  }
  goto <D.47042>;
  <D.47008>:
  {
    struct MonoInst * inst;

    D.47010 = cfg->mempool;
    inst = mono_mempool_alloc (D.47010, 80);
    inst->data.op[1].const_val = 0;
    D.47043 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47043;
    inst->prev = 0B;
    D.47044 = inst->prev;
    inst->next = D.47044;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47045 = inst->sreg3;
    inst->sreg2 = D.47045;
    D.47046 = inst->sreg2;
    inst->sreg1 = D.47046;
    D.47019 = cfg->ip;
    inst->cil_code = D.47019;
    inst->dreg = -1;
    inst->sreg1 = max_iid_reg;
    D.47047 = klass->interface_id;
    D.47048 = (long int) D.47047;
    inst->data.op[1].const_val = D.47048;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47049>; else goto <D.47050>;
    <D.47049>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47031->next = inst;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    inst->prev = D.47031;
    D.47030 = cfg->cbb;
    D.47030->last_ins = inst;
    goto <D.47051>;
    <D.47050>:
    D.47030 = cfg->cbb;
    D.47030 = cfg->cbb;
    D.47030->last_ins = inst;
    D.47031 = D.47030->last_ins;
    D.47030->code = D.47031;
    <D.47051>:
  }
  <D.47042>:
  if (false_target != 0B) goto <D.47052>; else goto <D.47053>;
  <D.47052>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.47010 = cfg->mempool;
    ins = mono_mempool_alloc (D.47010, 80);
    ins->data.op[1].const_val = 0;
    D.47054 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47054;
    ins->prev = 0B;
    D.47055 = ins->prev;
    ins->next = D.47055;
    ins->opcode = 560;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47056 = ins->sreg3;
    ins->sreg2 = D.47056;
    D.47057 = ins->sreg2;
    ins->sreg1 = D.47057;
    D.47019 = cfg->ip;
    ins->cil_code = D.47019;
    if (0 != 0) goto <D.47058>; else goto <D.47059>;
    <D.47058>:
    D.47010 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47010, 296);
    D.47060 = cfg->num_bblocks;
    D.47061 = D.47060;
    D.47062 = D.47061 + 1;
    cfg->num_bblocks = D.47062;
    D.47063 = (int) D.47061;
    falsebb->block_num = D.47063;
    ins->data.op[0].target_block = false_target;
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, false_target);
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47064>; else goto <D.47065>;
    <D.47064>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47031->next = ins;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    ins->prev = D.47031;
    D.47030 = cfg->cbb;
    D.47030->last_ins = ins;
    goto <D.47066>;
    <D.47065>:
    D.47030 = cfg->cbb;
    D.47030 = cfg->cbb;
    D.47030->last_ins = ins;
    D.47031 = D.47030->last_ins;
    D.47030->code = D.47031;
    <D.47066>:
    D.47067 = falsebb->cil_code;
    if (D.47067 != 0B) goto <D.47068>; else goto <D.47069>;
    <D.47068>:
    D.47070 = cfg->cil_offset_to_bb;
    D.47067 = falsebb->cil_code;
    D.47071 = (long int) D.47067;
    D.47072 = cfg->cil_start;
    D.47073 = (long int) D.47072;
    D.47074 = D.47071 - D.47073;
    D.47075 = (long unsigned int) D.47074;
    D.47076 = D.47075 * 8;
    D.47077 = D.47070 + D.47076;
    *D.47077 = falsebb;
    <D.47069>:
    D.47078 = cfg->real_offset;
    falsebb->real_offset = D.47078;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47082>; else goto <D.47079>;
    <D.47082>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47084 = D.47083 + 64985;
    if (D.47084 <= 9) goto <D.47080>; else goto <D.47085>;
    <D.47085>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47086 = D.47083 + 64878;
    if (D.47086 <= 9) goto <D.47080>; else goto <D.47087>;
    <D.47087>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47088 = D.47083 + 64888;
    if (D.47088 <= 9) goto <D.47080>; else goto <D.47079>;
    <D.47080>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47089 = D.47031->data.op[1].many_blocks;
    D.47090 = D.47089 + 8;
    D.47091 = *D.47090;
    if (D.47091 == 0B) goto <D.47092>; else goto <D.47079>;
    <D.47092>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47089 = D.47031->data.op[1].many_blocks;
    D.47090 = D.47089 + 8;
    *D.47090 = falsebb;
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, falsebb);
    goto <D.47081>;
    <D.47079>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 == 0B) goto <D.47093>; else goto <D.47095>;
    <D.47095>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    if (D.47083 != 442) goto <D.47096>; else goto <D.47094>;
    <D.47096>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    if (D.47083 != 759) goto <D.47097>; else goto <D.47094>;
    <D.47097>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47084 = D.47083 + 64985;
    if (D.47084 > 9) goto <D.47098>; else goto <D.47094>;
    <D.47098>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47086 = D.47083 + 64878;
    if (D.47086 > 9) goto <D.47099>; else goto <D.47094>;
    <D.47099>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47088 = D.47083 + 64888;
    if (D.47088 > 9) goto <D.47093>; else goto <D.47094>;
    <D.47093>:
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, falsebb);
    <D.47094>:
    <D.47081>:
    D.47030 = cfg->cbb;
    D.47030->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47100>;
    <D.47059>:
    D.47010 = cfg->mempool;
    D.47101 = mono_mempool_alloc (D.47010, 16);
    ins->data.op[1].many_blocks = D.47101;
    D.47102 = ins->data.op[1].many_blocks;
    *D.47102 = false_target;
    D.47102 = ins->data.op[1].many_blocks;
    D.47103 = D.47102 + 8;
    *D.47103 = 0B;
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, false_target);
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47104>; else goto <D.47105>;
    <D.47104>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47031->next = ins;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    ins->prev = D.47031;
    D.47030 = cfg->cbb;
    D.47030->last_ins = ins;
    goto <D.47106>;
    <D.47105>:
    D.47030 = cfg->cbb;
    D.47030 = cfg->cbb;
    D.47030->last_ins = ins;
    D.47031 = D.47030->last_ins;
    D.47030->code = D.47031;
    <D.47106>:
    D.47005 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47107 = D.47005 & 34359738368;
    if (D.47107 == 0) goto <D.47108>; else goto <D.47109>;
    <D.47108>:
    D.47010 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47010, 296);
    D.47060 = cfg->num_bblocks;
    D.47110 = D.47060;
    D.47111 = D.47110 + 1;
    cfg->num_bblocks = D.47111;
    D.47112 = (int) D.47110;
    falsebb->block_num = D.47112;
    D.47102 = ins->data.op[1].many_blocks;
    D.47103 = D.47102 + 8;
    *D.47103 = falsebb;
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, falsebb);
    D.47067 = falsebb->cil_code;
    if (D.47067 != 0B) goto <D.47113>; else goto <D.47114>;
    <D.47113>:
    D.47070 = cfg->cil_offset_to_bb;
    D.47067 = falsebb->cil_code;
    D.47071 = (long int) D.47067;
    D.47072 = cfg->cil_start;
    D.47073 = (long int) D.47072;
    D.47074 = D.47071 - D.47073;
    D.47075 = (long unsigned int) D.47074;
    D.47076 = D.47075 * 8;
    D.47077 = D.47070 + D.47076;
    *D.47077 = falsebb;
    <D.47114>:
    D.47078 = cfg->real_offset;
    falsebb->real_offset = D.47078;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47118>; else goto <D.47115>;
    <D.47118>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47084 = D.47083 + 64985;
    if (D.47084 <= 9) goto <D.47116>; else goto <D.47119>;
    <D.47119>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47086 = D.47083 + 64878;
    if (D.47086 <= 9) goto <D.47116>; else goto <D.47120>;
    <D.47120>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47088 = D.47083 + 64888;
    if (D.47088 <= 9) goto <D.47116>; else goto <D.47115>;
    <D.47116>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47089 = D.47031->data.op[1].many_blocks;
    D.47090 = D.47089 + 8;
    D.47091 = *D.47090;
    if (D.47091 == 0B) goto <D.47121>; else goto <D.47115>;
    <D.47121>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47089 = D.47031->data.op[1].many_blocks;
    D.47090 = D.47089 + 8;
    *D.47090 = falsebb;
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, falsebb);
    goto <D.47117>;
    <D.47115>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 == 0B) goto <D.47122>; else goto <D.47124>;
    <D.47124>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    if (D.47083 != 442) goto <D.47125>; else goto <D.47123>;
    <D.47125>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    if (D.47083 != 759) goto <D.47126>; else goto <D.47123>;
    <D.47126>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47084 = D.47083 + 64985;
    if (D.47084 > 9) goto <D.47127>; else goto <D.47123>;
    <D.47127>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47086 = D.47083 + 64878;
    if (D.47086 > 9) goto <D.47128>; else goto <D.47123>;
    <D.47128>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47083 = D.47031->opcode;
    D.47088 = D.47083 + 64888;
    if (D.47088 > 9) goto <D.47122>; else goto <D.47123>;
    <D.47122>:
    D.47030 = cfg->cbb;
    mono_link_bblock (cfg, D.47030, falsebb);
    <D.47123>:
    <D.47117>:
    D.47030 = cfg->cbb;
    D.47030->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47129>;
    <D.47109>:
    D.47030 = cfg->cbb;
    D.47030->extended = 1;
    <D.47129>:
    <D.47100>:
  }
  goto <D.47130>;
  <D.47053>:
  {
    struct MonoInst * inst;

    D.47010 = cfg->mempool;
    inst = mono_mempool_alloc (D.47010, 80);
    inst->data.op[1].const_val = 0;
    D.47131 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47131;
    inst->prev = 0B;
    D.47132 = inst->prev;
    inst->next = D.47132;
    inst->opcode = 460;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47133 = inst->sreg3;
    inst->sreg2 = D.47133;
    D.47134 = inst->sreg2;
    inst->sreg1 = D.47134;
    D.47019 = cfg->ip;
    inst->cil_code = D.47019;
    inst->data.op[1].p = "InvalidCastException";
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    if (D.47031 != 0B) goto <D.47135>; else goto <D.47136>;
    <D.47135>:
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    D.47031->next = inst;
    D.47030 = cfg->cbb;
    D.47031 = D.47030->last_ins;
    inst->prev = D.47031;
    D.47030 = cfg->cbb;
    D.47030->last_ins = inst;
    goto <D.47137>;
    <D.47136>:
    D.47030 = cfg->cbb;
    D.47030 = cfg->cbb;
    D.47030->last_ins = inst;
    D.47031 = D.47030->last_ins;
    D.47030->code = D.47031;
    <D.47137>:
  }
  <D.47130>:
}


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.47138;
  unsigned int D.47139;
  struct MonoMemPool * D.47140;
  long int D.47141;
  struct MonoInst * D.47142;
  int D.47143;
  int D.47144;
  const unsigned char * D.47145;
  long int D.47146;
  struct MonoBasicBlock * D.47147;
  struct MonoInst * D.47148;
  long unsigned int D.47152;
  long unsigned int D.47153;
  unsigned int D.47156;
  unsigned int D.47157;
  unsigned int D.47158;
  unsigned int D.47159;
  unsigned int D.47160;
  unsigned int D.47161;
  long int D.47162;
  struct MonoInst * D.47163;
  guint16 iftmp.435;
  int D.47168;
  int D.47169;
  long int D.47172;
  struct MonoInst * D.47173;
  int D.47174;
  int D.47175;
  int D.47176;
  unsigned int D.47178;
  int D.47179;
  long int D.47183;
  struct MonoInst * D.47184;
  int D.47185;
  int D.47186;
  long int D.47190;
  struct MonoInst * D.47191;
  int D.47192;
  int D.47193;
  long int D.47197;
  struct MonoInst * D.47198;
  int D.47199;
  int D.47200;
  long int D.47204;
  struct MonoInst * D.47205;
  int D.47206;
  int D.47207;
  long int D.47211;
  struct MonoInst * D.47212;
  int D.47213;
  int D.47214;
  long int D.47218;
  struct MonoInst * D.47219;
  int D.47220;
  int D.47221;
  long int D.47225;
  struct MonoInst * D.47226;
  int D.47227;
  int D.47228;
  long int D.47233;
  struct MonoInst * D.47234;
  int D.47235;
  int D.47236;
  short unsigned int D.47237;
  short unsigned int D.47238;
  long int D.47239;
  long int D.47243;
  struct MonoInst * D.47244;
  int D.47245;
  int D.47246;
  int D.47247;
  int D.47248;
  int D.47249;
  long int D.47250;
  int ibitmap_reg;
  int ibitmap_byte_reg;

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

    D.47140 = cfg->mempool;
    inst = mono_mempool_alloc (D.47140, 80);
    inst->data.op[1].const_val = 0;
    D.47141 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47141;
    inst->prev = 0B;
    D.47142 = inst->prev;
    inst->next = D.47142;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47143 = inst->sreg3;
    inst->sreg2 = D.47143;
    D.47144 = inst->sreg2;
    inst->sreg1 = D.47144;
    D.47145 = cfg->ip;
    inst->cil_code = D.47145;
    inst->dreg = ibitmap_reg;
    inst->sreg1 = base_reg;
    D.47146 = (long int) offset;
    inst->data.op[0].const_val = D.47146;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    if (D.47148 != 0B) goto <D.47149>; else goto <D.47150>;
    <D.47149>:
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    D.47148->next = inst;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    inst->prev = D.47148;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    goto <D.47151>;
    <D.47150>:
    D.47147 = cfg->cbb;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    D.47148 = D.47147->last_ins;
    D.47147->code = D.47148;
    <D.47151>:
  }
  D.47152 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47153 = D.47152 & 274877906944;
  if (D.47153 != 0) goto <D.47154>; else goto <D.47155>;
  <D.47154>:
  {
    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.47156 = alloc_preg (cfg);
    iid_reg = (int) D.47156;
    D.47157 = alloc_preg (cfg);
    shifted_iid_reg = (int) D.47157;
    D.47158 = alloc_preg (cfg);
    ibitmap_byte_address_reg = (int) D.47158;
    D.47159 = alloc_preg (cfg);
    masked_iid_reg = (int) D.47159;
    D.47160 = alloc_preg (cfg);
    iid_one_bit_reg = (int) D.47160;
    D.47161 = alloc_preg (cfg);
    iid_bit_reg = (int) D.47161;
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47162 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47162;
      inst->prev = 0B;
      D.47163 = inst->prev;
      inst->next = D.47163;
      D.47152 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47153 = D.47152 & 274877906944;
      if (D.47153 != 0) goto <D.47165>; else goto <D.47166>;
      <D.47165>:
      iftmp.435 = 734;
      goto <D.47167>;
      <D.47166>:
      iftmp.435 = 363;
      <D.47167>:
      inst->opcode = iftmp.435;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47168 = inst->sreg3;
      inst->sreg2 = D.47168;
      D.47169 = inst->sreg2;
      inst->sreg1 = D.47169;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      D.47152 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47153 = D.47152 & 274877906944;
      if (D.47153 != 0) goto <D.47170>; else goto <D.47171>;
      <D.47170>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.47140 = cfg->mempool;
        group = mono_mempool_alloc (D.47140, 80);
        group->data.op[1].const_val = 0;
        D.47172 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.47172;
        group->prev = 0B;
        D.47173 = group->prev;
        group->next = D.47173;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.47174 = group->sreg3;
        group->sreg2 = D.47174;
        D.47175 = group->sreg2;
        group->sreg1 = D.47175;
        D.47145 = cfg->ip;
        group->cil_code = D.47145;
        group->data.op[0].src = klass;
        group->data.op[1].src = 23B;
        D.47176 = got_loc->dreg;
        inst->sreg1 = D.47176;
        inst->data.op[1].p = group;
      }
      goto <D.47177>;
      <D.47171>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 23B;
      <D.47177>:
      inst->type = 3;
      D.47178 = alloc_dreg (cfg, 3);
      D.47179 = (int) D.47178;
      inst->dreg = D.47179;
      inst->dreg = iid_reg;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47180>; else goto <D.47181>;
      <D.47180>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47182>;
      <D.47181>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47182>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47183 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47183;
      inst->prev = 0B;
      D.47184 = inst->prev;
      inst->next = D.47184;
      inst->opcode = 440;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47185 = inst->sreg3;
      inst->sreg2 = D.47185;
      D.47186 = inst->sreg2;
      inst->sreg1 = D.47186;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = shifted_iid_reg;
      inst->sreg1 = iid_reg;
      inst->data.op[1].const_val = 3;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47187>; else goto <D.47188>;
      <D.47187>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47189>;
      <D.47188>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47189>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47190 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47190;
      inst->prev = 0B;
      D.47191 = inst->prev;
      inst->next = D.47191;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47192 = inst->sreg3;
      inst->sreg2 = D.47192;
      D.47193 = inst->sreg2;
      inst->sreg1 = D.47193;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = ibitmap_byte_address_reg;
      inst->sreg1 = ibitmap_reg;
      inst->sreg2 = shifted_iid_reg;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47194>; else goto <D.47195>;
      <D.47194>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47196>;
      <D.47195>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47196>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47197 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47197;
      inst->prev = 0B;
      D.47198 = inst->prev;
      inst->next = D.47198;
      inst->opcode = 390;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47199 = inst->sreg3;
      inst->sreg2 = D.47199;
      D.47200 = inst->sreg2;
      inst->sreg1 = D.47200;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = ibitmap_byte_reg;
      inst->sreg1 = ibitmap_byte_address_reg;
      inst->data.op[0].const_val = 0;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47201>; else goto <D.47202>;
      <D.47201>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47203>;
      <D.47202>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47203>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47204 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47204;
      inst->prev = 0B;
      D.47205 = inst->prev;
      inst->next = D.47205;
      inst->opcode = 632;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47206 = inst->sreg3;
      inst->sreg2 = D.47206;
      D.47207 = inst->sreg2;
      inst->sreg1 = D.47207;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = masked_iid_reg;
      inst->sreg1 = iid_reg;
      inst->data.op[1].const_val = 7;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47208>; else goto <D.47209>;
      <D.47208>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47210>;
      <D.47209>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47210>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 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 = 362;
      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.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = iid_one_bit_reg;
      inst->data.op[0].const_val = 1;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47215>; else goto <D.47216>;
      <D.47215>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47217>;
      <D.47216>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47217>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47218 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47218;
      inst->prev = 0B;
      D.47219 = inst->prev;
      inst->next = D.47219;
      inst->opcode = 575;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47220 = inst->sreg3;
      inst->sreg2 = D.47220;
      D.47221 = inst->sreg2;
      inst->sreg1 = D.47221;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = iid_bit_reg;
      inst->sreg1 = iid_one_bit_reg;
      inst->sreg2 = masked_iid_reg;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47222>; else goto <D.47223>;
      <D.47222>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47224>;
      <D.47223>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47224>:
    }
    {
      struct MonoInst * inst;

      D.47140 = cfg->mempool;
      inst = mono_mempool_alloc (D.47140, 80);
      inst->data.op[1].const_val = 0;
      D.47225 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47225;
      inst->prev = 0B;
      D.47226 = inst->prev;
      inst->next = D.47226;
      inst->opcode = 572;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47227 = inst->sreg3;
      inst->sreg2 = D.47227;
      D.47228 = inst->sreg2;
      inst->sreg1 = D.47228;
      D.47145 = cfg->ip;
      inst->cil_code = D.47145;
      inst->dreg = intf_bit_reg;
      inst->sreg1 = ibitmap_byte_reg;
      inst->sreg2 = iid_bit_reg;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      if (D.47148 != 0B) goto <D.47229>; else goto <D.47230>;
      <D.47229>:
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      D.47148->next = inst;
      D.47147 = cfg->cbb;
      D.47148 = D.47147->last_ins;
      inst->prev = D.47148;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      goto <D.47231>;
      <D.47230>:
      D.47147 = cfg->cbb;
      D.47147 = cfg->cbb;
      D.47147->last_ins = inst;
      D.47148 = D.47147->last_ins;
      D.47147->code = D.47148;
      <D.47231>:
    }
  }
  goto <D.47232>;
  <D.47155>:
  {
    struct MonoInst * inst;

    D.47140 = cfg->mempool;
    inst = mono_mempool_alloc (D.47140, 80);
    inst->data.op[1].const_val = 0;
    D.47233 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47233;
    inst->prev = 0B;
    D.47234 = inst->prev;
    inst->next = D.47234;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47235 = inst->sreg3;
    inst->sreg2 = D.47235;
    D.47236 = inst->sreg2;
    inst->sreg1 = D.47236;
    D.47145 = cfg->ip;
    inst->cil_code = D.47145;
    inst->dreg = ibitmap_byte_reg;
    inst->sreg1 = ibitmap_reg;
    D.47237 = klass->interface_id;
    D.47238 = D.47237 >> 3;
    D.47239 = (long int) D.47238;
    inst->data.op[0].const_val = D.47239;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    if (D.47148 != 0B) goto <D.47240>; else goto <D.47241>;
    <D.47240>:
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    D.47148->next = inst;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    inst->prev = D.47148;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    goto <D.47242>;
    <D.47241>:
    D.47147 = cfg->cbb;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    D.47148 = D.47147->last_ins;
    D.47147->code = D.47148;
    <D.47242>:
  }
  {
    struct MonoInst * inst;

    D.47140 = cfg->mempool;
    inst = mono_mempool_alloc (D.47140, 80);
    inst->data.op[1].const_val = 0;
    D.47243 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47243;
    inst->prev = 0B;
    D.47244 = inst->prev;
    inst->next = D.47244;
    inst->opcode = 436;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47245 = inst->sreg3;
    inst->sreg2 = D.47245;
    D.47246 = inst->sreg2;
    inst->sreg1 = D.47246;
    D.47145 = cfg->ip;
    inst->cil_code = D.47145;
    inst->dreg = intf_bit_reg;
    inst->sreg1 = ibitmap_byte_reg;
    D.47237 = klass->interface_id;
    D.47247 = (int) D.47237;
    D.47248 = D.47247 & 7;
    D.47249 = 1 << D.47248;
    D.47250 = (long int) D.47249;
    inst->data.op[1].const_val = D.47250;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    if (D.47148 != 0B) goto <D.47251>; else goto <D.47252>;
    <D.47251>:
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    D.47148->next = inst;
    D.47147 = cfg->cbb;
    D.47148 = D.47147->last_ins;
    inst->prev = D.47148;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    goto <D.47253>;
    <D.47252>:
    D.47147 = cfg->cbb;
    D.47147 = cfg->cbb;
    D.47147->last_ins = inst;
    D.47148 = D.47147->last_ins;
    D.47147->code = D.47148;
    <D.47253>:
  }
  <D.47232>:
}


mini_emit_class_check_branch (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, int branch_op, struct MonoBasicBlock * target)
{
  long unsigned int D.47254;
  long unsigned int D.47255;
  unsigned int D.47258;
  struct MonoMemPool * D.47259;
  long int D.47260;
  struct MonoInst * D.47261;
  guint16 iftmp.436;
  int D.47266;
  int D.47267;
  const unsigned char * D.47268;
  long int D.47271;
  struct MonoInst * D.47272;
  int D.47273;
  int D.47274;
  int D.47275;
  unsigned int D.47277;
  int D.47278;
  struct MonoBasicBlock * D.47279;
  struct MonoInst * D.47280;
  long int D.47284;
  struct MonoInst * D.47285;
  int D.47286;
  int D.47287;
  long int D.47292;
  struct MonoInst * D.47293;
  int D.47294;
  int D.47295;
  long int klass.437;
  long int D.47300;
  struct MonoInst * D.47301;
  short unsigned int D.47302;
  int D.47303;
  int D.47304;
  unsigned int D.47307;
  unsigned int D.47308;
  unsigned int D.47309;
  int D.47310;
  unsigned char * D.47314;
  struct MonoBasicBlock * * D.47317;
  long int D.47318;
  unsigned char * D.47319;
  long int D.47320;
  long int D.47321;
  long unsigned int D.47322;
  long unsigned int D.47323;
  struct MonoBasicBlock * * D.47324;
  unsigned int D.47325;
  short unsigned int D.47330;
  short unsigned int D.47331;
  short unsigned int D.47333;
  short unsigned int D.47335;
  struct MonoBasicBlock * * D.47336;
  struct MonoBasicBlock * * D.47337;
  struct MonoBasicBlock * D.47338;
  void * D.47348;
  struct MonoBasicBlock * * D.47349;
  struct MonoBasicBlock * * D.47350;
  long unsigned int D.47354;
  unsigned int D.47357;
  unsigned int D.47358;
  int D.47359;

  D.47254 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47255 = D.47254 & 274877906944;
  if (D.47255 != 0) goto <D.47256>; else goto <D.47257>;
  <D.47256>:
  {
    int const_reg;

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

      D.47259 = cfg->mempool;
      inst = mono_mempool_alloc (D.47259, 80);
      inst->data.op[1].const_val = 0;
      D.47260 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47260;
      inst->prev = 0B;
      D.47261 = inst->prev;
      inst->next = D.47261;
      D.47254 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47255 = D.47254 & 274877906944;
      if (D.47255 != 0) goto <D.47263>; else goto <D.47264>;
      <D.47263>:
      iftmp.436 = 734;
      goto <D.47265>;
      <D.47264>:
      iftmp.436 = 363;
      <D.47265>:
      inst->opcode = iftmp.436;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47266 = inst->sreg3;
      inst->sreg2 = D.47266;
      D.47267 = inst->sreg2;
      inst->sreg1 = D.47267;
      D.47268 = cfg->ip;
      inst->cil_code = D.47268;
      D.47254 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47255 = D.47254 & 274877906944;
      if (D.47255 != 0) goto <D.47269>; else goto <D.47270>;
      <D.47269>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.47259 = cfg->mempool;
        group = mono_mempool_alloc (D.47259, 80);
        group->data.op[1].const_val = 0;
        D.47271 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.47271;
        group->prev = 0B;
        D.47272 = group->prev;
        group->next = D.47272;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.47273 = group->sreg3;
        group->sreg2 = D.47273;
        D.47274 = group->sreg2;
        group->sreg1 = D.47274;
        D.47268 = cfg->ip;
        group->cil_code = D.47268;
        group->data.op[0].src = klass;
        group->data.op[1].src = 11B;
        D.47275 = got_loc->dreg;
        inst->sreg1 = D.47275;
        inst->data.op[1].p = group;
      }
      goto <D.47276>;
      <D.47270>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 11B;
      <D.47276>:
      inst->type = 3;
      D.47277 = alloc_dreg (cfg, 3);
      D.47278 = (int) D.47277;
      inst->dreg = D.47278;
      inst->dreg = const_reg;
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      if (D.47280 != 0B) goto <D.47281>; else goto <D.47282>;
      <D.47281>:
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      D.47280->next = inst;
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      inst->prev = D.47280;
      D.47279 = cfg->cbb;
      D.47279->last_ins = inst;
      goto <D.47283>;
      <D.47282>:
      D.47279 = cfg->cbb;
      D.47279 = cfg->cbb;
      D.47279->last_ins = inst;
      D.47280 = D.47279->last_ins;
      D.47279->code = D.47280;
      <D.47283>:
    }
    {
      struct MonoInst * inst;

      D.47259 = cfg->mempool;
      inst = mono_mempool_alloc (D.47259, 80);
      inst->data.op[1].const_val = 0;
      D.47284 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47284;
      inst->prev = 0B;
      D.47285 = inst->prev;
      inst->next = D.47285;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47286 = inst->sreg3;
      inst->sreg2 = D.47286;
      D.47287 = inst->sreg2;
      inst->sreg1 = D.47287;
      D.47268 = cfg->ip;
      inst->cil_code = D.47268;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      inst->sreg2 = const_reg;
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      if (D.47280 != 0B) goto <D.47288>; else goto <D.47289>;
      <D.47288>:
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      D.47280->next = inst;
      D.47279 = cfg->cbb;
      D.47280 = D.47279->last_ins;
      inst->prev = D.47280;
      D.47279 = cfg->cbb;
      D.47279->last_ins = inst;
      goto <D.47290>;
      <D.47289>:
      D.47279 = cfg->cbb;
      D.47279 = cfg->cbb;
      D.47279->last_ins = inst;
      D.47280 = D.47279->last_ins;
      D.47279->code = D.47280;
      <D.47290>:
    }
  }
  goto <D.47291>;
  <D.47257>:
  {
    struct MonoInst * inst;

    D.47259 = cfg->mempool;
    inst = mono_mempool_alloc (D.47259, 80);
    inst->data.op[1].const_val = 0;
    D.47292 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47292;
    inst->prev = 0B;
    D.47293 = inst->prev;
    inst->next = D.47293;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47294 = inst->sreg3;
    inst->sreg2 = D.47294;
    D.47295 = inst->sreg2;
    inst->sreg1 = D.47295;
    D.47268 = cfg->ip;
    inst->cil_code = D.47268;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    klass.437 = (long int) klass;
    inst->data.op[1].const_val = klass.437;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 != 0B) goto <D.47297>; else goto <D.47298>;
    <D.47297>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47280->next = inst;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    inst->prev = D.47280;
    D.47279 = cfg->cbb;
    D.47279->last_ins = inst;
    goto <D.47299>;
    <D.47298>:
    D.47279 = cfg->cbb;
    D.47279 = cfg->cbb;
    D.47279->last_ins = inst;
    D.47280 = D.47279->last_ins;
    D.47279->code = D.47280;
    <D.47299>:
  }
  <D.47291>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.47259 = cfg->mempool;
    ins = mono_mempool_alloc (D.47259, 80);
    ins->data.op[1].const_val = 0;
    D.47300 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47300;
    ins->prev = 0B;
    D.47301 = ins->prev;
    ins->next = D.47301;
    D.47302 = (short unsigned int) branch_op;
    ins->opcode = D.47302;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47303 = ins->sreg3;
    ins->sreg2 = D.47303;
    D.47304 = ins->sreg2;
    ins->sreg1 = D.47304;
    D.47268 = cfg->ip;
    ins->cil_code = D.47268;
    if (branch_op == 442) goto <D.47305>; else goto <D.47306>;
    <D.47305>:
    D.47259 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47259, 296);
    D.47307 = cfg->num_bblocks;
    D.47308 = D.47307;
    D.47309 = D.47308 + 1;
    cfg->num_bblocks = D.47309;
    D.47310 = (int) D.47308;
    falsebb->block_num = D.47310;
    ins->data.op[0].target_block = target;
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, target);
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 != 0B) goto <D.47311>; else goto <D.47312>;
    <D.47311>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47280->next = ins;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    ins->prev = D.47280;
    D.47279 = cfg->cbb;
    D.47279->last_ins = ins;
    goto <D.47313>;
    <D.47312>:
    D.47279 = cfg->cbb;
    D.47279 = cfg->cbb;
    D.47279->last_ins = ins;
    D.47280 = D.47279->last_ins;
    D.47279->code = D.47280;
    <D.47313>:
    D.47314 = falsebb->cil_code;
    if (D.47314 != 0B) goto <D.47315>; else goto <D.47316>;
    <D.47315>:
    D.47317 = cfg->cil_offset_to_bb;
    D.47314 = falsebb->cil_code;
    D.47318 = (long int) D.47314;
    D.47319 = cfg->cil_start;
    D.47320 = (long int) D.47319;
    D.47321 = D.47318 - D.47320;
    D.47322 = (long unsigned int) D.47321;
    D.47323 = D.47322 * 8;
    D.47324 = D.47317 + D.47323;
    *D.47324 = falsebb;
    <D.47316>:
    D.47325 = cfg->real_offset;
    falsebb->real_offset = D.47325;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 != 0B) goto <D.47329>; else goto <D.47326>;
    <D.47329>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47331 = D.47330 + 64985;
    if (D.47331 <= 9) goto <D.47327>; else goto <D.47332>;
    <D.47332>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47333 = D.47330 + 64878;
    if (D.47333 <= 9) goto <D.47327>; else goto <D.47334>;
    <D.47334>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47335 = D.47330 + 64888;
    if (D.47335 <= 9) goto <D.47327>; else goto <D.47326>;
    <D.47327>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47336 = D.47280->data.op[1].many_blocks;
    D.47337 = D.47336 + 8;
    D.47338 = *D.47337;
    if (D.47338 == 0B) goto <D.47339>; else goto <D.47326>;
    <D.47339>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47336 = D.47280->data.op[1].many_blocks;
    D.47337 = D.47336 + 8;
    *D.47337 = falsebb;
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, falsebb);
    goto <D.47328>;
    <D.47326>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 == 0B) goto <D.47340>; else goto <D.47342>;
    <D.47342>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    if (D.47330 != 442) goto <D.47343>; else goto <D.47341>;
    <D.47343>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    if (D.47330 != 759) goto <D.47344>; else goto <D.47341>;
    <D.47344>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47331 = D.47330 + 64985;
    if (D.47331 > 9) goto <D.47345>; else goto <D.47341>;
    <D.47345>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47333 = D.47330 + 64878;
    if (D.47333 > 9) goto <D.47346>; else goto <D.47341>;
    <D.47346>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47335 = D.47330 + 64888;
    if (D.47335 > 9) goto <D.47340>; else goto <D.47341>;
    <D.47340>:
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, falsebb);
    <D.47341>:
    <D.47328>:
    D.47279 = cfg->cbb;
    D.47279->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47347>;
    <D.47306>:
    D.47259 = cfg->mempool;
    D.47348 = mono_mempool_alloc (D.47259, 16);
    ins->data.op[1].many_blocks = D.47348;
    D.47349 = ins->data.op[1].many_blocks;
    *D.47349 = target;
    D.47349 = ins->data.op[1].many_blocks;
    D.47350 = D.47349 + 8;
    *D.47350 = 0B;
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, target);
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 != 0B) goto <D.47351>; else goto <D.47352>;
    <D.47351>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47280->next = ins;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    ins->prev = D.47280;
    D.47279 = cfg->cbb;
    D.47279->last_ins = ins;
    goto <D.47353>;
    <D.47352>:
    D.47279 = cfg->cbb;
    D.47279 = cfg->cbb;
    D.47279->last_ins = ins;
    D.47280 = D.47279->last_ins;
    D.47279->code = D.47280;
    <D.47353>:
    D.47254 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47354 = D.47254 & 34359738368;
    if (D.47354 == 0) goto <D.47355>; else goto <D.47356>;
    <D.47355>:
    D.47259 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47259, 296);
    D.47307 = cfg->num_bblocks;
    D.47357 = D.47307;
    D.47358 = D.47357 + 1;
    cfg->num_bblocks = D.47358;
    D.47359 = (int) D.47357;
    falsebb->block_num = D.47359;
    D.47349 = ins->data.op[1].many_blocks;
    D.47350 = D.47349 + 8;
    *D.47350 = falsebb;
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, falsebb);
    D.47314 = falsebb->cil_code;
    if (D.47314 != 0B) goto <D.47360>; else goto <D.47361>;
    <D.47360>:
    D.47317 = cfg->cil_offset_to_bb;
    D.47314 = falsebb->cil_code;
    D.47318 = (long int) D.47314;
    D.47319 = cfg->cil_start;
    D.47320 = (long int) D.47319;
    D.47321 = D.47318 - D.47320;
    D.47322 = (long unsigned int) D.47321;
    D.47323 = D.47322 * 8;
    D.47324 = D.47317 + D.47323;
    *D.47324 = falsebb;
    <D.47361>:
    D.47325 = cfg->real_offset;
    falsebb->real_offset = D.47325;
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 != 0B) goto <D.47365>; else goto <D.47362>;
    <D.47365>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47331 = D.47330 + 64985;
    if (D.47331 <= 9) goto <D.47363>; else goto <D.47366>;
    <D.47366>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47333 = D.47330 + 64878;
    if (D.47333 <= 9) goto <D.47363>; else goto <D.47367>;
    <D.47367>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47335 = D.47330 + 64888;
    if (D.47335 <= 9) goto <D.47363>; else goto <D.47362>;
    <D.47363>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47336 = D.47280->data.op[1].many_blocks;
    D.47337 = D.47336 + 8;
    D.47338 = *D.47337;
    if (D.47338 == 0B) goto <D.47368>; else goto <D.47362>;
    <D.47368>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47336 = D.47280->data.op[1].many_blocks;
    D.47337 = D.47336 + 8;
    *D.47337 = falsebb;
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, falsebb);
    goto <D.47364>;
    <D.47362>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    if (D.47280 == 0B) goto <D.47369>; else goto <D.47371>;
    <D.47371>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    if (D.47330 != 442) goto <D.47372>; else goto <D.47370>;
    <D.47372>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    if (D.47330 != 759) goto <D.47373>; else goto <D.47370>;
    <D.47373>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47331 = D.47330 + 64985;
    if (D.47331 > 9) goto <D.47374>; else goto <D.47370>;
    <D.47374>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47333 = D.47330 + 64878;
    if (D.47333 > 9) goto <D.47375>; else goto <D.47370>;
    <D.47375>:
    D.47279 = cfg->cbb;
    D.47280 = D.47279->last_ins;
    D.47330 = D.47280->opcode;
    D.47335 = D.47330 + 64888;
    if (D.47335 > 9) goto <D.47369>; else goto <D.47370>;
    <D.47369>:
    D.47279 = cfg->cbb;
    mono_link_bblock (cfg, D.47279, falsebb);
    <D.47370>:
    <D.47364>:
    D.47279 = cfg->cbb;
    D.47279->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47376>;
    <D.47356>:
    D.47279 = cfg->cbb;
    D.47279->extended = 1;
    <D.47376>:
    <D.47347>:
  }
}


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.47377;
  struct MonoMemPool * D.47378;
  long int D.47379;
  struct MonoInst * D.47380;
  int D.47381;
  int D.47382;
  const unsigned char * D.47383;
  struct MonoBasicBlock * D.47384;
  struct MonoInst * D.47385;
  long int D.47391;
  struct MonoInst * D.47392;
  int D.47393;
  int D.47394;
  unsigned int D.47397;
  unsigned int D.47398;
  unsigned int D.47399;
  int D.47400;
  unsigned char * D.47404;
  struct MonoBasicBlock * * D.47407;
  long int D.47408;
  unsigned char * D.47409;
  long int D.47410;
  long int D.47411;
  long unsigned int D.47412;
  long unsigned int D.47413;
  struct MonoBasicBlock * * D.47414;
  unsigned int D.47415;
  short unsigned int D.47420;
  short unsigned int D.47421;
  short unsigned int D.47423;
  short unsigned int D.47425;
  struct MonoBasicBlock * * D.47426;
  struct MonoBasicBlock * * D.47427;
  struct MonoBasicBlock * D.47428;
  void * D.47438;
  struct MonoBasicBlock * * D.47439;
  struct MonoBasicBlock * * D.47440;
  long unsigned int D.47444;
  long unsigned int D.47445;
  unsigned int D.47448;
  unsigned int D.47449;
  int D.47450;
  long int D.47469;
  struct MonoInst * D.47470;
  int D.47471;
  int D.47472;
  int intf_bit_reg;

  D.47377 = alloc_preg (cfg);
  intf_bit_reg = (int) D.47377;
  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.47378 = cfg->mempool;
    inst = mono_mempool_alloc (D.47378, 80);
    inst->data.op[1].const_val = 0;
    D.47379 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47379;
    inst->prev = 0B;
    D.47380 = inst->prev;
    inst->next = D.47380;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47381 = inst->sreg3;
    inst->sreg2 = D.47381;
    D.47382 = inst->sreg2;
    inst->sreg1 = D.47382;
    D.47383 = cfg->ip;
    inst->cil_code = D.47383;
    inst->dreg = -1;
    inst->sreg1 = intf_bit_reg;
    inst->data.op[1].const_val = 0;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47386>; else goto <D.47387>;
    <D.47386>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47385->next = inst;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    inst->prev = D.47385;
    D.47384 = cfg->cbb;
    D.47384->last_ins = inst;
    goto <D.47388>;
    <D.47387>:
    D.47384 = cfg->cbb;
    D.47384 = cfg->cbb;
    D.47384->last_ins = inst;
    D.47385 = D.47384->last_ins;
    D.47384->code = D.47385;
    <D.47388>:
  }
  if (true_target != 0B) goto <D.47389>; else goto <D.47390>;
  <D.47389>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.47378 = cfg->mempool;
    ins = mono_mempool_alloc (D.47378, 80);
    ins->data.op[1].const_val = 0;
    D.47391 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47391;
    ins->prev = 0B;
    D.47392 = ins->prev;
    ins->next = D.47392;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47393 = ins->sreg3;
    ins->sreg2 = D.47393;
    D.47394 = ins->sreg2;
    ins->sreg1 = D.47394;
    D.47383 = cfg->ip;
    ins->cil_code = D.47383;
    if (0 != 0) goto <D.47395>; else goto <D.47396>;
    <D.47395>:
    D.47378 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47378, 296);
    D.47397 = cfg->num_bblocks;
    D.47398 = D.47397;
    D.47399 = D.47398 + 1;
    cfg->num_bblocks = D.47399;
    D.47400 = (int) D.47398;
    falsebb->block_num = D.47400;
    ins->data.op[0].target_block = true_target;
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, true_target);
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47401>; else goto <D.47402>;
    <D.47401>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47385->next = ins;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    ins->prev = D.47385;
    D.47384 = cfg->cbb;
    D.47384->last_ins = ins;
    goto <D.47403>;
    <D.47402>:
    D.47384 = cfg->cbb;
    D.47384 = cfg->cbb;
    D.47384->last_ins = ins;
    D.47385 = D.47384->last_ins;
    D.47384->code = D.47385;
    <D.47403>:
    D.47404 = falsebb->cil_code;
    if (D.47404 != 0B) goto <D.47405>; else goto <D.47406>;
    <D.47405>:
    D.47407 = cfg->cil_offset_to_bb;
    D.47404 = falsebb->cil_code;
    D.47408 = (long int) D.47404;
    D.47409 = cfg->cil_start;
    D.47410 = (long int) D.47409;
    D.47411 = D.47408 - D.47410;
    D.47412 = (long unsigned int) D.47411;
    D.47413 = D.47412 * 8;
    D.47414 = D.47407 + D.47413;
    *D.47414 = falsebb;
    <D.47406>:
    D.47415 = cfg->real_offset;
    falsebb->real_offset = D.47415;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47419>; else goto <D.47416>;
    <D.47419>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47421 = D.47420 + 64985;
    if (D.47421 <= 9) goto <D.47417>; else goto <D.47422>;
    <D.47422>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47423 = D.47420 + 64878;
    if (D.47423 <= 9) goto <D.47417>; else goto <D.47424>;
    <D.47424>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47425 = D.47420 + 64888;
    if (D.47425 <= 9) goto <D.47417>; else goto <D.47416>;
    <D.47417>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47426 = D.47385->data.op[1].many_blocks;
    D.47427 = D.47426 + 8;
    D.47428 = *D.47427;
    if (D.47428 == 0B) goto <D.47429>; else goto <D.47416>;
    <D.47429>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47426 = D.47385->data.op[1].many_blocks;
    D.47427 = D.47426 + 8;
    *D.47427 = falsebb;
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, falsebb);
    goto <D.47418>;
    <D.47416>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 == 0B) goto <D.47430>; else goto <D.47432>;
    <D.47432>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    if (D.47420 != 442) goto <D.47433>; else goto <D.47431>;
    <D.47433>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    if (D.47420 != 759) goto <D.47434>; else goto <D.47431>;
    <D.47434>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47421 = D.47420 + 64985;
    if (D.47421 > 9) goto <D.47435>; else goto <D.47431>;
    <D.47435>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47423 = D.47420 + 64878;
    if (D.47423 > 9) goto <D.47436>; else goto <D.47431>;
    <D.47436>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47425 = D.47420 + 64888;
    if (D.47425 > 9) goto <D.47430>; else goto <D.47431>;
    <D.47430>:
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, falsebb);
    <D.47431>:
    <D.47418>:
    D.47384 = cfg->cbb;
    D.47384->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47437>;
    <D.47396>:
    D.47378 = cfg->mempool;
    D.47438 = mono_mempool_alloc (D.47378, 16);
    ins->data.op[1].many_blocks = D.47438;
    D.47439 = ins->data.op[1].many_blocks;
    *D.47439 = true_target;
    D.47439 = ins->data.op[1].many_blocks;
    D.47440 = D.47439 + 8;
    *D.47440 = 0B;
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, true_target);
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47441>; else goto <D.47442>;
    <D.47441>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47385->next = ins;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    ins->prev = D.47385;
    D.47384 = cfg->cbb;
    D.47384->last_ins = ins;
    goto <D.47443>;
    <D.47442>:
    D.47384 = cfg->cbb;
    D.47384 = cfg->cbb;
    D.47384->last_ins = ins;
    D.47385 = D.47384->last_ins;
    D.47384->code = D.47385;
    <D.47443>:
    D.47444 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47445 = D.47444 & 34359738368;
    if (D.47445 == 0) goto <D.47446>; else goto <D.47447>;
    <D.47446>:
    D.47378 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47378, 296);
    D.47397 = cfg->num_bblocks;
    D.47448 = D.47397;
    D.47449 = D.47448 + 1;
    cfg->num_bblocks = D.47449;
    D.47450 = (int) D.47448;
    falsebb->block_num = D.47450;
    D.47439 = ins->data.op[1].many_blocks;
    D.47440 = D.47439 + 8;
    *D.47440 = falsebb;
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, falsebb);
    D.47404 = falsebb->cil_code;
    if (D.47404 != 0B) goto <D.47451>; else goto <D.47452>;
    <D.47451>:
    D.47407 = cfg->cil_offset_to_bb;
    D.47404 = falsebb->cil_code;
    D.47408 = (long int) D.47404;
    D.47409 = cfg->cil_start;
    D.47410 = (long int) D.47409;
    D.47411 = D.47408 - D.47410;
    D.47412 = (long unsigned int) D.47411;
    D.47413 = D.47412 * 8;
    D.47414 = D.47407 + D.47413;
    *D.47414 = falsebb;
    <D.47452>:
    D.47415 = cfg->real_offset;
    falsebb->real_offset = D.47415;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47456>; else goto <D.47453>;
    <D.47456>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47421 = D.47420 + 64985;
    if (D.47421 <= 9) goto <D.47454>; else goto <D.47457>;
    <D.47457>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47423 = D.47420 + 64878;
    if (D.47423 <= 9) goto <D.47454>; else goto <D.47458>;
    <D.47458>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47425 = D.47420 + 64888;
    if (D.47425 <= 9) goto <D.47454>; else goto <D.47453>;
    <D.47454>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47426 = D.47385->data.op[1].many_blocks;
    D.47427 = D.47426 + 8;
    D.47428 = *D.47427;
    if (D.47428 == 0B) goto <D.47459>; else goto <D.47453>;
    <D.47459>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47426 = D.47385->data.op[1].many_blocks;
    D.47427 = D.47426 + 8;
    *D.47427 = falsebb;
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, falsebb);
    goto <D.47455>;
    <D.47453>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 == 0B) goto <D.47460>; else goto <D.47462>;
    <D.47462>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    if (D.47420 != 442) goto <D.47463>; else goto <D.47461>;
    <D.47463>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    if (D.47420 != 759) goto <D.47464>; else goto <D.47461>;
    <D.47464>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47421 = D.47420 + 64985;
    if (D.47421 > 9) goto <D.47465>; else goto <D.47461>;
    <D.47465>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47423 = D.47420 + 64878;
    if (D.47423 > 9) goto <D.47466>; else goto <D.47461>;
    <D.47466>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47420 = D.47385->opcode;
    D.47425 = D.47420 + 64888;
    if (D.47425 > 9) goto <D.47460>; else goto <D.47461>;
    <D.47460>:
    D.47384 = cfg->cbb;
    mono_link_bblock (cfg, D.47384, falsebb);
    <D.47461>:
    <D.47455>:
    D.47384 = cfg->cbb;
    D.47384->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47467>;
    <D.47447>:
    D.47384 = cfg->cbb;
    D.47384->extended = 1;
    <D.47467>:
    <D.47437>:
  }
  goto <D.47468>;
  <D.47390>:
  {
    struct MonoInst * inst;

    D.47378 = cfg->mempool;
    inst = mono_mempool_alloc (D.47378, 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 = 451;
    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.47383 = cfg->ip;
    inst->cil_code = D.47383;
    inst->data.op[1].p = "InvalidCastException";
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    if (D.47385 != 0B) goto <D.47473>; else goto <D.47474>;
    <D.47473>:
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    D.47385->next = inst;
    D.47384 = cfg->cbb;
    D.47385 = D.47384->last_ins;
    inst->prev = D.47385;
    D.47384 = cfg->cbb;
    D.47384->last_ins = inst;
    goto <D.47475>;
    <D.47474>:
    D.47384 = cfg->cbb;
    D.47384 = cfg->cbb;
    D.47384->last_ins = inst;
    D.47385 = D.47384->last_ins;
    D.47384->code = D.47385;
    <D.47475>:
  }
  <D.47468>:
}


mini_emit_max_iid_check_class (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target)
{
  unsigned int D.47476;
  struct MonoMemPool * D.47477;
  long int D.47478;
  struct MonoInst * D.47479;
  int D.47480;
  int D.47481;
  const unsigned char * D.47482;
  struct MonoBasicBlock * D.47483;
  struct MonoInst * D.47484;
  int max_iid_reg;

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

    D.47477 = cfg->mempool;
    inst = mono_mempool_alloc (D.47477, 80);
    inst->data.op[1].const_val = 0;
    D.47478 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47478;
    inst->prev = 0B;
    D.47479 = inst->prev;
    inst->next = D.47479;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47480 = inst->sreg3;
    inst->sreg2 = D.47480;
    D.47481 = inst->sreg2;
    inst->sreg1 = D.47481;
    D.47482 = cfg->ip;
    inst->cil_code = D.47482;
    inst->dreg = max_iid_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 92;
    D.47483 = cfg->cbb;
    D.47484 = D.47483->last_ins;
    if (D.47484 != 0B) goto <D.47485>; else goto <D.47486>;
    <D.47485>:
    D.47483 = cfg->cbb;
    D.47484 = D.47483->last_ins;
    D.47484->next = inst;
    D.47483 = cfg->cbb;
    D.47484 = D.47483->last_ins;
    inst->prev = D.47484;
    D.47483 = cfg->cbb;
    D.47483->last_ins = inst;
    goto <D.47487>;
    <D.47486>:
    D.47483 = cfg->cbb;
    D.47483 = cfg->cbb;
    D.47483->last_ins = inst;
    D.47484 = D.47483->last_ins;
    D.47483->code = D.47484;
    <D.47487>:
  }
  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.47488;
  unsigned int D.47489;
  unsigned int D.47490;
  short unsigned int D.47491;
  struct MonoMemPool * D.47494;
  long int D.47495;
  struct MonoInst * D.47496;
  int D.47497;
  int D.47498;
  const unsigned char * D.47499;
  struct MonoBasicBlock * D.47500;
  struct MonoInst * D.47501;
  long int D.47505;
  struct MonoInst * D.47506;
  int D.47507;
  int D.47508;
  long int D.47509;
  long int D.47513;
  struct MonoInst * D.47514;
  int D.47515;
  int D.47516;
  unsigned int D.47519;
  unsigned int D.47520;
  unsigned int D.47521;
  int D.47522;
  unsigned char * D.47526;
  struct MonoBasicBlock * * D.47529;
  long int D.47530;
  unsigned char * D.47531;
  long int D.47532;
  long int D.47533;
  long unsigned int D.47534;
  long unsigned int D.47535;
  struct MonoBasicBlock * * D.47536;
  unsigned int D.47537;
  short unsigned int D.47542;
  short unsigned int D.47543;
  short unsigned int D.47545;
  short unsigned int D.47547;
  struct MonoBasicBlock * * D.47548;
  struct MonoBasicBlock * * D.47549;
  struct MonoBasicBlock * D.47550;
  void * D.47560;
  struct MonoBasicBlock * * D.47561;
  struct MonoBasicBlock * * D.47562;
  long unsigned int D.47566;
  long unsigned int D.47567;
  unsigned int D.47570;
  unsigned int D.47571;
  int D.47572;
  long int D.47590;
  struct MonoInst * D.47591;
  int D.47592;
  int D.47593;
  long int D.47597;
  struct MonoInst * D.47598;
  int D.47599;
  int D.47600;
  int D.47601;
  int D.47602;
  int D.47603;
  long int D.47604;
  long int D.47610;
  struct MonoInst * D.47611;
  int D.47612;
  int D.47613;
  int D.47614;
  long unsigned int D.47619;
  unsigned int D.47622;
  long int D.47623;
  struct MonoInst * D.47624;
  guint16 iftmp.438;
  int D.47629;
  int D.47630;
  long int D.47633;
  struct MonoInst * D.47634;
  int D.47635;
  int D.47636;
  int D.47637;
  unsigned int D.47639;
  int D.47640;
  long int D.47644;
  struct MonoInst * D.47645;
  int D.47646;
  int D.47647;
  long int D.47652;
  struct MonoInst * D.47653;
  int D.47654;
  int D.47655;
  long int klass.439;
  long int D.47660;
  struct MonoInst * D.47661;
  int D.47662;
  int D.47663;
  unsigned int D.47666;
  unsigned int D.47667;
  int D.47668;
  unsigned char * D.47672;
  long int D.47675;
  long int D.47676;
  long unsigned int D.47677;
  long unsigned int D.47678;
  struct MonoBasicBlock * * D.47679;
  void * D.47695;
  struct MonoBasicBlock * * D.47696;
  struct MonoBasicBlock * * D.47697;
  unsigned int D.47703;
  unsigned int D.47704;
  int D.47705;
  int idepth_reg;
  int stypes_reg;
  int stype;

  D.47488 = alloc_preg (cfg);
  idepth_reg = (int) D.47488;
  D.47489 = alloc_preg (cfg);
  stypes_reg = (int) D.47489;
  D.47490 = alloc_preg (cfg);
  stype = (int) D.47490;
  mono_class_setup_supertypes (klass);
  D.47491 = klass->idepth;
  if (D.47491 > 6) goto <D.47492>; else goto <D.47493>;
  <D.47492>:
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 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;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47497 = inst->sreg3;
    inst->sreg2 = D.47497;
    D.47498 = inst->sreg2;
    inst->sreg1 = D.47498;
    D.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = idepth_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 24;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47502>; else goto <D.47503>;
    <D.47502>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47504>;
    <D.47503>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47504>:
  }
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 80);
    inst->data.op[1].const_val = 0;
    D.47505 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47505;
    inst->prev = 0B;
    D.47506 = inst->prev;
    inst->next = D.47506;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47507 = inst->sreg3;
    inst->sreg2 = D.47507;
    D.47508 = inst->sreg2;
    inst->sreg1 = D.47508;
    D.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = -1;
    inst->sreg1 = idepth_reg;
    D.47491 = klass->idepth;
    D.47509 = (long int) D.47491;
    inst->data.op[1].const_val = D.47509;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47510>; else goto <D.47511>;
    <D.47510>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47512>;
    <D.47511>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47512>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.47494 = cfg->mempool;
    ins = mono_mempool_alloc (D.47494, 80);
    ins->data.op[1].const_val = 0;
    D.47513 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47513;
    ins->prev = 0B;
    D.47514 = ins->prev;
    ins->next = D.47514;
    ins->opcode = 560;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47515 = ins->sreg3;
    ins->sreg2 = D.47515;
    D.47516 = ins->sreg2;
    ins->sreg1 = D.47516;
    D.47499 = cfg->ip;
    ins->cil_code = D.47499;
    if (0 != 0) goto <D.47517>; else goto <D.47518>;
    <D.47517>:
    D.47494 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47494, 296);
    D.47519 = cfg->num_bblocks;
    D.47520 = D.47519;
    D.47521 = D.47520 + 1;
    cfg->num_bblocks = D.47521;
    D.47522 = (int) D.47520;
    falsebb->block_num = D.47522;
    ins->data.op[0].target_block = false_target;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, false_target);
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47523>; else goto <D.47524>;
    <D.47523>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = ins;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    ins->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    goto <D.47525>;
    <D.47524>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47525>:
    D.47526 = falsebb->cil_code;
    if (D.47526 != 0B) goto <D.47527>; else goto <D.47528>;
    <D.47527>:
    D.47529 = cfg->cil_offset_to_bb;
    D.47526 = falsebb->cil_code;
    D.47530 = (long int) D.47526;
    D.47531 = cfg->cil_start;
    D.47532 = (long int) D.47531;
    D.47533 = D.47530 - D.47532;
    D.47534 = (long unsigned int) D.47533;
    D.47535 = D.47534 * 8;
    D.47536 = D.47529 + D.47535;
    *D.47536 = falsebb;
    <D.47528>:
    D.47537 = cfg->real_offset;
    falsebb->real_offset = D.47537;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47541>; else goto <D.47538>;
    <D.47541>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 <= 9) goto <D.47539>; else goto <D.47544>;
    <D.47544>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 <= 9) goto <D.47539>; else goto <D.47546>;
    <D.47546>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 <= 9) goto <D.47539>; else goto <D.47538>;
    <D.47539>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    D.47550 = *D.47549;
    if (D.47550 == 0B) goto <D.47551>; else goto <D.47538>;
    <D.47551>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    *D.47549 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    goto <D.47540>;
    <D.47538>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 == 0B) goto <D.47552>; else goto <D.47554>;
    <D.47554>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 442) goto <D.47555>; else goto <D.47553>;
    <D.47555>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 759) goto <D.47556>; else goto <D.47553>;
    <D.47556>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 > 9) goto <D.47557>; else goto <D.47553>;
    <D.47557>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 > 9) goto <D.47558>; else goto <D.47553>;
    <D.47558>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 > 9) goto <D.47552>; else goto <D.47553>;
    <D.47552>:
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    <D.47553>:
    <D.47540>:
    D.47500 = cfg->cbb;
    D.47500->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47559>;
    <D.47518>:
    D.47494 = cfg->mempool;
    D.47560 = mono_mempool_alloc (D.47494, 16);
    ins->data.op[1].many_blocks = D.47560;
    D.47561 = ins->data.op[1].many_blocks;
    *D.47561 = false_target;
    D.47561 = ins->data.op[1].many_blocks;
    D.47562 = D.47561 + 8;
    *D.47562 = 0B;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, false_target);
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47563>; else goto <D.47564>;
    <D.47563>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = ins;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    ins->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    goto <D.47565>;
    <D.47564>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47565>:
    D.47566 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47567 = D.47566 & 34359738368;
    if (D.47567 == 0) goto <D.47568>; else goto <D.47569>;
    <D.47568>:
    D.47494 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47494, 296);
    D.47519 = cfg->num_bblocks;
    D.47570 = D.47519;
    D.47571 = D.47570 + 1;
    cfg->num_bblocks = D.47571;
    D.47572 = (int) D.47570;
    falsebb->block_num = D.47572;
    D.47561 = ins->data.op[1].many_blocks;
    D.47562 = D.47561 + 8;
    *D.47562 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    D.47526 = falsebb->cil_code;
    if (D.47526 != 0B) goto <D.47573>; else goto <D.47574>;
    <D.47573>:
    D.47529 = cfg->cil_offset_to_bb;
    D.47526 = falsebb->cil_code;
    D.47530 = (long int) D.47526;
    D.47531 = cfg->cil_start;
    D.47532 = (long int) D.47531;
    D.47533 = D.47530 - D.47532;
    D.47534 = (long unsigned int) D.47533;
    D.47535 = D.47534 * 8;
    D.47536 = D.47529 + D.47535;
    *D.47536 = falsebb;
    <D.47574>:
    D.47537 = cfg->real_offset;
    falsebb->real_offset = D.47537;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47578>; else goto <D.47575>;
    <D.47578>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 <= 9) goto <D.47576>; else goto <D.47579>;
    <D.47579>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 <= 9) goto <D.47576>; else goto <D.47580>;
    <D.47580>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 <= 9) goto <D.47576>; else goto <D.47575>;
    <D.47576>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    D.47550 = *D.47549;
    if (D.47550 == 0B) goto <D.47581>; else goto <D.47575>;
    <D.47581>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    *D.47549 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    goto <D.47577>;
    <D.47575>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 == 0B) goto <D.47582>; else goto <D.47584>;
    <D.47584>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 442) goto <D.47585>; else goto <D.47583>;
    <D.47585>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 759) goto <D.47586>; else goto <D.47583>;
    <D.47586>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 > 9) goto <D.47587>; else goto <D.47583>;
    <D.47587>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 > 9) goto <D.47588>; else goto <D.47583>;
    <D.47588>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 > 9) goto <D.47582>; else goto <D.47583>;
    <D.47582>:
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    <D.47583>:
    <D.47577>:
    D.47500 = cfg->cbb;
    D.47500->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47589>;
    <D.47569>:
    D.47500 = cfg->cbb;
    D.47500->extended = 1;
    <D.47589>:
    <D.47559>:
  }
  <D.47493>:
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 80);
    inst->data.op[1].const_val = 0;
    D.47590 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47590;
    inst->prev = 0B;
    D.47591 = inst->prev;
    inst->next = D.47591;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47592 = inst->sreg3;
    inst->sreg2 = D.47592;
    D.47593 = inst->sreg2;
    inst->sreg1 = D.47593;
    D.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = stypes_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 16;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47594>; else goto <D.47595>;
    <D.47594>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47596>;
    <D.47595>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47596>:
  }
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 80);
    inst->data.op[1].const_val = 0;
    D.47597 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47597;
    inst->prev = 0B;
    D.47598 = inst->prev;
    inst->next = D.47598;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47599 = inst->sreg3;
    inst->sreg2 = D.47599;
    D.47600 = inst->sreg2;
    inst->sreg1 = D.47600;
    D.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = stype;
    inst->sreg1 = stypes_reg;
    D.47491 = klass->idepth;
    D.47601 = (int) D.47491;
    D.47602 = D.47601 + -1;
    D.47603 = D.47602 * 8;
    D.47604 = (long int) D.47603;
    inst->data.op[0].const_val = D.47604;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47605>; else goto <D.47606>;
    <D.47605>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47607>;
    <D.47606>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47607>:
  }
  if (klass_ins != 0B) goto <D.47608>; else goto <D.47609>;
  <D.47608>:
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 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 = 322;
    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.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = -1;
    inst->sreg1 = stype;
    D.47614 = klass_ins->dreg;
    inst->sreg2 = D.47614;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47615>; else goto <D.47616>;
    <D.47615>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47617>;
    <D.47616>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47617>:
  }
  goto <D.47618>;
  <D.47609>:
  D.47566 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47619 = D.47566 & 274877906944;
  if (D.47619 != 0) goto <D.47620>; else goto <D.47621>;
  <D.47620>:
  {
    int const_reg;

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

      D.47494 = cfg->mempool;
      inst = mono_mempool_alloc (D.47494, 80);
      inst->data.op[1].const_val = 0;
      D.47623 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47623;
      inst->prev = 0B;
      D.47624 = inst->prev;
      inst->next = D.47624;
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47619 = D.47566 & 274877906944;
      if (D.47619 != 0) goto <D.47626>; else goto <D.47627>;
      <D.47626>:
      iftmp.438 = 734;
      goto <D.47628>;
      <D.47627>:
      iftmp.438 = 363;
      <D.47628>:
      inst->opcode = iftmp.438;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47629 = inst->sreg3;
      inst->sreg2 = D.47629;
      D.47630 = inst->sreg2;
      inst->sreg1 = D.47630;
      D.47499 = cfg->ip;
      inst->cil_code = D.47499;
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47619 = D.47566 & 274877906944;
      if (D.47619 != 0) goto <D.47631>; else goto <D.47632>;
      <D.47631>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.47494 = cfg->mempool;
        group = mono_mempool_alloc (D.47494, 80);
        group->data.op[1].const_val = 0;
        D.47633 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.47633;
        group->prev = 0B;
        D.47634 = group->prev;
        group->next = D.47634;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.47635 = group->sreg3;
        group->sreg2 = D.47635;
        D.47636 = group->sreg2;
        group->sreg1 = D.47636;
        D.47499 = cfg->ip;
        group->cil_code = D.47499;
        group->data.op[0].src = klass;
        group->data.op[1].src = 11B;
        D.47637 = got_loc->dreg;
        inst->sreg1 = D.47637;
        inst->data.op[1].p = group;
      }
      goto <D.47638>;
      <D.47632>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 11B;
      <D.47638>:
      inst->type = 3;
      D.47639 = alloc_dreg (cfg, 3);
      D.47640 = (int) D.47639;
      inst->dreg = D.47640;
      inst->dreg = const_reg;
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      if (D.47501 != 0B) goto <D.47641>; else goto <D.47642>;
      <D.47641>:
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      D.47501->next = inst;
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      inst->prev = D.47501;
      D.47500 = cfg->cbb;
      D.47500->last_ins = inst;
      goto <D.47643>;
      <D.47642>:
      D.47500 = cfg->cbb;
      D.47500 = cfg->cbb;
      D.47500->last_ins = inst;
      D.47501 = D.47500->last_ins;
      D.47500->code = D.47501;
      <D.47643>:
    }
    {
      struct MonoInst * inst;

      D.47494 = cfg->mempool;
      inst = mono_mempool_alloc (D.47494, 80);
      inst->data.op[1].const_val = 0;
      D.47644 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47644;
      inst->prev = 0B;
      D.47645 = inst->prev;
      inst->next = D.47645;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47646 = inst->sreg3;
      inst->sreg2 = D.47646;
      D.47647 = inst->sreg2;
      inst->sreg1 = D.47647;
      D.47499 = cfg->ip;
      inst->cil_code = D.47499;
      inst->dreg = -1;
      inst->sreg1 = stype;
      inst->sreg2 = const_reg;
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      if (D.47501 != 0B) goto <D.47648>; else goto <D.47649>;
      <D.47648>:
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      D.47501->next = inst;
      D.47500 = cfg->cbb;
      D.47501 = D.47500->last_ins;
      inst->prev = D.47501;
      D.47500 = cfg->cbb;
      D.47500->last_ins = inst;
      goto <D.47650>;
      <D.47649>:
      D.47500 = cfg->cbb;
      D.47500 = cfg->cbb;
      D.47500->last_ins = inst;
      D.47501 = D.47500->last_ins;
      D.47500->code = D.47501;
      <D.47650>:
    }
  }
  goto <D.47651>;
  <D.47621>:
  {
    struct MonoInst * inst;

    D.47494 = cfg->mempool;
    inst = mono_mempool_alloc (D.47494, 80);
    inst->data.op[1].const_val = 0;
    D.47652 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47652;
    inst->prev = 0B;
    D.47653 = inst->prev;
    inst->next = D.47653;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47654 = inst->sreg3;
    inst->sreg2 = D.47654;
    D.47655 = inst->sreg2;
    inst->sreg1 = D.47655;
    D.47499 = cfg->ip;
    inst->cil_code = D.47499;
    inst->dreg = -1;
    inst->sreg1 = stype;
    klass.439 = (long int) klass;
    inst->data.op[1].const_val = klass.439;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47657>; else goto <D.47658>;
    <D.47657>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = inst;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    inst->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    goto <D.47659>;
    <D.47658>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = inst;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47659>:
  }
  <D.47651>:
  <D.47618>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.47494 = cfg->mempool;
    ins = mono_mempool_alloc (D.47494, 80);
    ins->data.op[1].const_val = 0;
    D.47660 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47660;
    ins->prev = 0B;
    D.47661 = ins->prev;
    ins->next = D.47661;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47662 = ins->sreg3;
    ins->sreg2 = D.47662;
    D.47663 = ins->sreg2;
    ins->sreg1 = D.47663;
    D.47499 = cfg->ip;
    ins->cil_code = D.47499;
    if (0 != 0) goto <D.47664>; else goto <D.47665>;
    <D.47664>:
    D.47494 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47494, 296);
    D.47519 = cfg->num_bblocks;
    D.47666 = D.47519;
    D.47667 = D.47666 + 1;
    cfg->num_bblocks = D.47667;
    D.47668 = (int) D.47666;
    falsebb->block_num = D.47668;
    ins->data.op[0].target_block = true_target;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, true_target);
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47669>; else goto <D.47670>;
    <D.47669>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = ins;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    ins->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    goto <D.47671>;
    <D.47670>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47671>:
    D.47672 = falsebb->cil_code;
    if (D.47672 != 0B) goto <D.47673>; else goto <D.47674>;
    <D.47673>:
    D.47529 = cfg->cil_offset_to_bb;
    D.47672 = falsebb->cil_code;
    D.47675 = (long int) D.47672;
    D.47531 = cfg->cil_start;
    D.47532 = (long int) D.47531;
    D.47676 = D.47675 - D.47532;
    D.47677 = (long unsigned int) D.47676;
    D.47678 = D.47677 * 8;
    D.47679 = D.47529 + D.47678;
    *D.47679 = falsebb;
    <D.47674>:
    D.47537 = cfg->real_offset;
    falsebb->real_offset = D.47537;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47683>; else goto <D.47680>;
    <D.47683>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 <= 9) goto <D.47681>; else goto <D.47684>;
    <D.47684>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 <= 9) goto <D.47681>; else goto <D.47685>;
    <D.47685>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 <= 9) goto <D.47681>; else goto <D.47680>;
    <D.47681>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    D.47550 = *D.47549;
    if (D.47550 == 0B) goto <D.47686>; else goto <D.47680>;
    <D.47686>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    *D.47549 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    goto <D.47682>;
    <D.47680>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 == 0B) goto <D.47687>; else goto <D.47689>;
    <D.47689>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 442) goto <D.47690>; else goto <D.47688>;
    <D.47690>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 759) goto <D.47691>; else goto <D.47688>;
    <D.47691>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 > 9) goto <D.47692>; else goto <D.47688>;
    <D.47692>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 > 9) goto <D.47693>; else goto <D.47688>;
    <D.47693>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 > 9) goto <D.47687>; else goto <D.47688>;
    <D.47687>:
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    <D.47688>:
    <D.47682>:
    D.47500 = cfg->cbb;
    D.47500->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47694>;
    <D.47665>:
    D.47494 = cfg->mempool;
    D.47695 = mono_mempool_alloc (D.47494, 16);
    ins->data.op[1].many_blocks = D.47695;
    D.47696 = ins->data.op[1].many_blocks;
    *D.47696 = true_target;
    D.47696 = ins->data.op[1].many_blocks;
    D.47697 = D.47696 + 8;
    *D.47697 = 0B;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, true_target);
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47698>; else goto <D.47699>;
    <D.47698>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47501->next = ins;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    ins->prev = D.47501;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    goto <D.47700>;
    <D.47699>:
    D.47500 = cfg->cbb;
    D.47500 = cfg->cbb;
    D.47500->last_ins = ins;
    D.47501 = D.47500->last_ins;
    D.47500->code = D.47501;
    <D.47700>:
    D.47566 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47567 = D.47566 & 34359738368;
    if (D.47567 == 0) goto <D.47701>; else goto <D.47702>;
    <D.47701>:
    D.47494 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.47494, 296);
    D.47519 = cfg->num_bblocks;
    D.47703 = D.47519;
    D.47704 = D.47703 + 1;
    cfg->num_bblocks = D.47704;
    D.47705 = (int) D.47703;
    falsebb->block_num = D.47705;
    D.47696 = ins->data.op[1].many_blocks;
    D.47697 = D.47696 + 8;
    *D.47697 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    D.47672 = falsebb->cil_code;
    if (D.47672 != 0B) goto <D.47706>; else goto <D.47707>;
    <D.47706>:
    D.47529 = cfg->cil_offset_to_bb;
    D.47672 = falsebb->cil_code;
    D.47675 = (long int) D.47672;
    D.47531 = cfg->cil_start;
    D.47532 = (long int) D.47531;
    D.47676 = D.47675 - D.47532;
    D.47677 = (long unsigned int) D.47676;
    D.47678 = D.47677 * 8;
    D.47679 = D.47529 + D.47678;
    *D.47679 = falsebb;
    <D.47707>:
    D.47537 = cfg->real_offset;
    falsebb->real_offset = D.47537;
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 != 0B) goto <D.47711>; else goto <D.47708>;
    <D.47711>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 <= 9) goto <D.47709>; else goto <D.47712>;
    <D.47712>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 <= 9) goto <D.47709>; else goto <D.47713>;
    <D.47713>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 <= 9) goto <D.47709>; else goto <D.47708>;
    <D.47709>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    D.47550 = *D.47549;
    if (D.47550 == 0B) goto <D.47714>; else goto <D.47708>;
    <D.47714>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47548 = D.47501->data.op[1].many_blocks;
    D.47549 = D.47548 + 8;
    *D.47549 = falsebb;
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    goto <D.47710>;
    <D.47708>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    if (D.47501 == 0B) goto <D.47715>; else goto <D.47717>;
    <D.47717>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 442) goto <D.47718>; else goto <D.47716>;
    <D.47718>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    if (D.47542 != 759) goto <D.47719>; else goto <D.47716>;
    <D.47719>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47543 = D.47542 + 64985;
    if (D.47543 > 9) goto <D.47720>; else goto <D.47716>;
    <D.47720>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47545 = D.47542 + 64878;
    if (D.47545 > 9) goto <D.47721>; else goto <D.47716>;
    <D.47721>:
    D.47500 = cfg->cbb;
    D.47501 = D.47500->last_ins;
    D.47542 = D.47501->opcode;
    D.47547 = D.47542 + 64888;
    if (D.47547 > 9) goto <D.47715>; else goto <D.47716>;
    <D.47715>:
    D.47500 = cfg->cbb;
    mono_link_bblock (cfg, D.47500, falsebb);
    <D.47716>:
    <D.47710>:
    D.47500 = cfg->cbb;
    D.47500->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.47722>;
    <D.47702>:
    D.47500 = cfg->cbb;
    D.47500->extended = 1;
    <D.47722>:
    <D.47694>:
  }
}


handle_unbox_gsharedvt (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * obj, struct MonoBasicBlock * * out_cbb)
{
  struct MonoInst * obj.440;
  struct MonoInst * obj.441;
  struct MonoMemPool * D.47725;
  unsigned int D.47726;
  unsigned int D.47727;
  unsigned int D.47728;
  int D.47729;
  unsigned int D.47730;
  unsigned int D.47731;
  int D.47732;
  unsigned int D.47733;
  unsigned int D.47734;
  int D.47735;
  long int D.47736;
  struct MonoInst * D.47737;
  int D.47738;
  int D.47739;
  const unsigned char * D.47740;
  int D.47741;
  struct MonoBasicBlock * D.47742;
  struct MonoInst * D.47743;
  long int D.47747;
  struct MonoInst * D.47748;
  int D.47749;
  int D.47750;
  unsigned int D.47753;
  unsigned int D.47754;
  int D.47755;
  unsigned char * D.47759;
  struct MonoBasicBlock * * D.47762;
  long int D.47763;
  unsigned char * D.47764;
  long int D.47765;
  long int D.47766;
  long unsigned int D.47767;
  long unsigned int D.47768;
  struct MonoBasicBlock * * D.47769;
  unsigned int D.47770;
  short unsigned int D.47775;
  short unsigned int D.47776;
  short unsigned int D.47778;
  short unsigned int D.47780;
  struct MonoBasicBlock * * D.47781;
  struct MonoBasicBlock * * D.47782;
  struct MonoBasicBlock * D.47783;
  void * D.47793;
  struct MonoBasicBlock * * D.47794;
  struct MonoBasicBlock * * D.47795;
  long unsigned int D.47799;
  long unsigned int D.47800;
  unsigned int D.47803;
  unsigned int D.47804;
  int D.47805;
  long int D.47823;
  struct MonoInst * D.47824;
  int D.47825;
  int D.47826;
  long int D.47830;
  struct MonoInst * D.47831;
  int D.47832;
  int D.47833;
  unsigned int D.47836;
  unsigned int D.47837;
  int D.47838;
  unsigned char * D.47842;
  long int D.47845;
  long int D.47846;
  long unsigned int D.47847;
  long unsigned int D.47848;
  struct MonoBasicBlock * * D.47849;
  void * D.47865;
  struct MonoBasicBlock * * D.47866;
  struct MonoBasicBlock * * D.47867;
  unsigned int D.47873;
  unsigned int D.47874;
  int D.47875;
  unsigned int D.47893;
  long int D.47894;
  struct MonoInst * D.47895;
  int D.47896;
  int D.47897;
  int D.47898;
  long int D.47902;
  struct MonoInst * D.47903;
  int D.47904;
  int D.47905;
  unsigned int D.47908;
  unsigned int D.47909;
  int D.47910;
  unsigned char * D.47914;
  long int D.47917;
  long int D.47918;
  long unsigned int D.47919;
  long unsigned int D.47920;
  struct MonoBasicBlock * * D.47921;
  void * D.47937;
  struct MonoBasicBlock * * D.47938;
  struct MonoBasicBlock * * D.47939;
  unsigned int D.47945;
  unsigned int D.47946;
  int D.47947;
  unsigned char * D.47965;
  long int D.47968;
  long int D.47969;
  long unsigned int D.47970;
  long unsigned int D.47971;
  struct MonoBasicBlock * * D.47972;
  unsigned int D.47987;
  struct MonoInst * iftmp.442;
  unsigned int dreg.443;
  unsigned int D.47990;
  struct MonoInst * * D.47993;
  long unsigned int D.47994;
  long unsigned int D.47995;
  struct MonoInst * * D.47996;
  struct MonoType * D.48000;
  unsigned char D.48001;
  unsigned char D.48002;
  struct MonoClass * D.48003;
  unsigned int D.48004;
  int D.48005;
  int D.48006;
  _Bool D.48007;
  long int D.48008;
  long int D.48009;
  struct MonoType * D.48012;
  int D.48013;
  struct MonoInst * iftmp.444;
  int D.48019;
  int D.48020;
  unsigned int D.48021;
  sizetype D.48024;
  sizetype D.48025;
  sizetype D.48026;
  struct MonoInst * * D.48027;
  struct MonoInst * iftmp.445;
  int D.48030;
  unsigned int D.48031;
  sizetype D.48034;
  sizetype D.48035;
  struct MonoInst * * D.48036;
  _Bool D.48038;
  long int D.48039;
  long int D.48040;
  _Bool D.48043;
  long int D.48044;
  long int D.48045;
  unsigned char D.48048;
  unsigned char D.48049;
  unsigned char D.48050;
  unsigned char D.48051;
  long int D.48055;
  struct MonoInst * D.48056;
  int D.48057;
  int D.48058;
  int D.48059;
  long int D.48063;
  struct MonoInst * D.48064;
  int D.48065;
  int D.48066;
  unsigned int D.48069;
  unsigned int D.48070;
  int D.48071;
  unsigned char * D.48075;
  long int D.48078;
  long int D.48079;
  long unsigned int D.48080;
  long unsigned int D.48081;
  struct MonoBasicBlock * * D.48082;
  void * D.48098;
  struct MonoBasicBlock * * D.48099;
  struct MonoBasicBlock * * D.48100;
  unsigned int D.48106;
  unsigned int D.48107;
  int D.48108;
  unsigned char * D.48126;
  long int D.48129;
  long int D.48130;
  long unsigned int D.48131;
  long unsigned int D.48132;
  struct MonoBasicBlock * * D.48133;
  struct MonoClass * D.48148;
  struct MonoType * D.48149;
  struct MonoInst * iftmp.446;
  int D.48151;
  unsigned int D.48152;
  long unsigned int D.48155;
  long unsigned int D.48156;
  struct MonoInst * * D.48157;
  long int D.48161;
  struct MonoInst * D.48162;
  int D.48163;
  int D.48164;
  unsigned char D.48165;
  unsigned char D.48166;
  struct MonoClass * D.48167;
  unsigned int D.48168;
  int D.48169;
  struct MonoType * D.48172;
  int D.48173;
  struct MonoInst * iftmp.447;
  int D.48179;
  int D.48180;
  unsigned int D.48181;
  sizetype D.48184;
  sizetype D.48185;
  sizetype D.48186;
  struct MonoInst * * D.48187;
  struct MonoInst * iftmp.448;
  int D.48190;
  unsigned int D.48191;
  sizetype D.48194;
  sizetype D.48195;
  struct MonoInst * * D.48196;
  _Bool D.48198;
  long int D.48199;
  long int D.48200;
  _Bool D.48203;
  long int D.48204;
  long int D.48205;
  unsigned char D.48208;
  unsigned char D.48209;
  unsigned char D.48210;
  unsigned char D.48211;
  long int D.48215;
  struct MonoInst * D.48216;
  int D.48217;
  int D.48218;
  unsigned int D.48221;
  unsigned int D.48222;
  int D.48223;
  unsigned char * D.48227;
  long int D.48230;
  long int D.48231;
  long unsigned int D.48232;
  long unsigned int D.48233;
  struct MonoBasicBlock * * D.48234;
  void * D.48250;
  struct MonoBasicBlock * * D.48251;
  struct MonoBasicBlock * * D.48252;
  unsigned int D.48258;
  unsigned int D.48259;
  int D.48260;
  unsigned char * D.48278;
  long int D.48281;
  long int D.48282;
  long unsigned int D.48283;
  long unsigned int D.48284;
  struct MonoBasicBlock * * D.48285;
  long int D.48300;
  struct MonoInst * D.48301;
  unsigned int D.48302;
  short unsigned int D.48303;
  int D.48304;
  int D.48305;
  unsigned char D.48306;
  <unnamed type> D.48307;
  unsigned int D.48308;
  int D.48309;
  struct MonoInst * D.48313;
  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.440 = obj;
      args[0] = obj.440;
      args[1] = klass_inst;
      obj.441 = mono_emit_jit_icall (cfg, mono_object_castclass_unbox, &args);
      obj = obj.441;
      D.47725 = cfg->mempool;
      is_ref_bb = mono_mempool_alloc0 (D.47725, 296);
      D.47726 = cfg->num_bblocks;
      D.47727 = D.47726;
      D.47728 = D.47727 + 1;
      cfg->num_bblocks = D.47728;
      D.47729 = (int) D.47727;
      is_ref_bb->block_num = D.47729;
      D.47725 = cfg->mempool;
      is_nullable_bb = mono_mempool_alloc0 (D.47725, 296);
      D.47726 = cfg->num_bblocks;
      D.47730 = D.47726;
      D.47731 = D.47730 + 1;
      cfg->num_bblocks = D.47731;
      D.47732 = (int) D.47730;
      is_nullable_bb->block_num = D.47732;
      D.47725 = cfg->mempool;
      end_bb = mono_mempool_alloc0 (D.47725, 296);
      D.47726 = cfg->num_bblocks;
      D.47733 = D.47726;
      D.47734 = D.47733 + 1;
      cfg->num_bblocks = D.47734;
      D.47735 = (int) D.47733;
      end_bb->block_num = D.47735;
      is_ref = emit_get_gsharedvt_info_klass (cfg, klass, 19);
      {
        struct MonoInst * inst;

        D.47725 = cfg->mempool;
        inst = mono_mempool_alloc (D.47725, 80);
        inst->data.op[1].const_val = 0;
        D.47736 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47736;
        inst->prev = 0B;
        D.47737 = inst->prev;
        inst->next = D.47737;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47738 = inst->sreg3;
        inst->sreg2 = D.47738;
        D.47739 = inst->sreg2;
        inst->sreg1 = D.47739;
        D.47740 = cfg->ip;
        inst->cil_code = D.47740;
        inst->dreg = -1;
        D.47741 = is_ref->dreg;
        inst->sreg1 = D.47741;
        inst->data.op[1].const_val = 1;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47744>; else goto <D.47745>;
        <D.47744>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = inst;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        inst->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        goto <D.47746>;
        <D.47745>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47746>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.47725 = cfg->mempool;
        ins = mono_mempool_alloc (D.47725, 80);
        ins->data.op[1].const_val = 0;
        D.47747 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.47747;
        ins->prev = 0B;
        D.47748 = ins->prev;
        ins->next = D.47748;
        ins->opcode = 648;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.47749 = ins->sreg3;
        ins->sreg2 = D.47749;
        D.47750 = ins->sreg2;
        ins->sreg1 = D.47750;
        D.47740 = cfg->ip;
        ins->cil_code = D.47740;
        if (0 != 0) goto <D.47751>; else goto <D.47752>;
        <D.47751>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47753 = D.47726;
        D.47754 = D.47753 + 1;
        cfg->num_bblocks = D.47754;
        D.47755 = (int) D.47753;
        falsebb->block_num = D.47755;
        ins->data.op[0].target_block = is_ref_bb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, is_ref_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47756>; else goto <D.47757>;
        <D.47756>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47758>;
        <D.47757>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47758>:
        D.47759 = falsebb->cil_code;
        if (D.47759 != 0B) goto <D.47760>; else goto <D.47761>;
        <D.47760>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47759 = falsebb->cil_code;
        D.47763 = (long int) D.47759;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47766 = D.47763 - D.47765;
        D.47767 = (long unsigned int) D.47766;
        D.47768 = D.47767 * 8;
        D.47769 = D.47762 + D.47768;
        *D.47769 = falsebb;
        <D.47761>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47774>; else goto <D.47771>;
        <D.47774>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47772>; else goto <D.47777>;
        <D.47777>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47772>; else goto <D.47779>;
        <D.47779>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47772>; else goto <D.47771>;
        <D.47772>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47784>; else goto <D.47771>;
        <D.47784>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47773>;
        <D.47771>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47785>; else goto <D.47787>;
        <D.47787>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47788>; else goto <D.47786>;
        <D.47788>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47789>; else goto <D.47786>;
        <D.47789>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47790>; else goto <D.47786>;
        <D.47790>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47791>; else goto <D.47786>;
        <D.47791>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47785>; else goto <D.47786>;
        <D.47785>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47786>:
        <D.47773>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47792>;
        <D.47752>:
        D.47725 = cfg->mempool;
        D.47793 = mono_mempool_alloc (D.47725, 16);
        ins->data.op[1].many_blocks = D.47793;
        D.47794 = ins->data.op[1].many_blocks;
        *D.47794 = is_ref_bb;
        D.47794 = ins->data.op[1].many_blocks;
        D.47795 = D.47794 + 8;
        *D.47795 = 0B;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, is_ref_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47796>; else goto <D.47797>;
        <D.47796>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47798>;
        <D.47797>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47798>:
        D.47799 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47800 = D.47799 & 34359738368;
        if (D.47800 == 0) goto <D.47801>; else goto <D.47802>;
        <D.47801>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47803 = D.47726;
        D.47804 = D.47803 + 1;
        cfg->num_bblocks = D.47804;
        D.47805 = (int) D.47803;
        falsebb->block_num = D.47805;
        D.47794 = ins->data.op[1].many_blocks;
        D.47795 = D.47794 + 8;
        *D.47795 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        D.47759 = falsebb->cil_code;
        if (D.47759 != 0B) goto <D.47806>; else goto <D.47807>;
        <D.47806>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47759 = falsebb->cil_code;
        D.47763 = (long int) D.47759;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47766 = D.47763 - D.47765;
        D.47767 = (long unsigned int) D.47766;
        D.47768 = D.47767 * 8;
        D.47769 = D.47762 + D.47768;
        *D.47769 = falsebb;
        <D.47807>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47811>; else goto <D.47808>;
        <D.47811>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47809>; else goto <D.47812>;
        <D.47812>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47809>; else goto <D.47813>;
        <D.47813>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47809>; else goto <D.47808>;
        <D.47809>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47814>; else goto <D.47808>;
        <D.47814>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47810>;
        <D.47808>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47815>; else goto <D.47817>;
        <D.47817>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47818>; else goto <D.47816>;
        <D.47818>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47819>; else goto <D.47816>;
        <D.47819>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47820>; else goto <D.47816>;
        <D.47820>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47821>; else goto <D.47816>;
        <D.47821>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47815>; else goto <D.47816>;
        <D.47815>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47816>:
        <D.47810>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47822>;
        <D.47802>:
        D.47742 = cfg->cbb;
        D.47742->extended = 1;
        <D.47822>:
        <D.47792>:
      }
      {
        struct MonoInst * inst;

        D.47725 = cfg->mempool;
        inst = mono_mempool_alloc (D.47725, 80);
        inst->data.op[1].const_val = 0;
        D.47823 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47823;
        inst->prev = 0B;
        D.47824 = inst->prev;
        inst->next = D.47824;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47825 = inst->sreg3;
        inst->sreg2 = D.47825;
        D.47826 = inst->sreg2;
        inst->sreg1 = D.47826;
        D.47740 = cfg->ip;
        inst->cil_code = D.47740;
        inst->dreg = -1;
        D.47741 = is_ref->dreg;
        inst->sreg1 = D.47741;
        inst->data.op[1].const_val = 2;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47827>; else goto <D.47828>;
        <D.47827>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = inst;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        inst->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        goto <D.47829>;
        <D.47828>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47829>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.47725 = cfg->mempool;
        ins = mono_mempool_alloc (D.47725, 80);
        ins->data.op[1].const_val = 0;
        D.47830 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.47830;
        ins->prev = 0B;
        D.47831 = ins->prev;
        ins->next = D.47831;
        ins->opcode = 648;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.47832 = ins->sreg3;
        ins->sreg2 = D.47832;
        D.47833 = ins->sreg2;
        ins->sreg1 = D.47833;
        D.47740 = cfg->ip;
        ins->cil_code = D.47740;
        if (0 != 0) goto <D.47834>; else goto <D.47835>;
        <D.47834>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47836 = D.47726;
        D.47837 = D.47836 + 1;
        cfg->num_bblocks = D.47837;
        D.47838 = (int) D.47836;
        falsebb->block_num = D.47838;
        ins->data.op[0].target_block = is_nullable_bb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, is_nullable_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47839>; else goto <D.47840>;
        <D.47839>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47841>;
        <D.47840>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47841>:
        D.47842 = falsebb->cil_code;
        if (D.47842 != 0B) goto <D.47843>; else goto <D.47844>;
        <D.47843>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47842 = falsebb->cil_code;
        D.47845 = (long int) D.47842;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47846 = D.47845 - D.47765;
        D.47847 = (long unsigned int) D.47846;
        D.47848 = D.47847 * 8;
        D.47849 = D.47762 + D.47848;
        *D.47849 = falsebb;
        <D.47844>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47853>; else goto <D.47850>;
        <D.47853>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47851>; else goto <D.47854>;
        <D.47854>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47851>; else goto <D.47855>;
        <D.47855>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47851>; else goto <D.47850>;
        <D.47851>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47856>; else goto <D.47850>;
        <D.47856>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47852>;
        <D.47850>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47857>; else goto <D.47859>;
        <D.47859>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47860>; else goto <D.47858>;
        <D.47860>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47861>; else goto <D.47858>;
        <D.47861>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47862>; else goto <D.47858>;
        <D.47862>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47863>; else goto <D.47858>;
        <D.47863>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47857>; else goto <D.47858>;
        <D.47857>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47858>:
        <D.47852>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47864>;
        <D.47835>:
        D.47725 = cfg->mempool;
        D.47865 = mono_mempool_alloc (D.47725, 16);
        ins->data.op[1].many_blocks = D.47865;
        D.47866 = ins->data.op[1].many_blocks;
        *D.47866 = is_nullable_bb;
        D.47866 = ins->data.op[1].many_blocks;
        D.47867 = D.47866 + 8;
        *D.47867 = 0B;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, is_nullable_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47868>; else goto <D.47869>;
        <D.47868>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47870>;
        <D.47869>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47870>:
        D.47799 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47800 = D.47799 & 34359738368;
        if (D.47800 == 0) goto <D.47871>; else goto <D.47872>;
        <D.47871>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47873 = D.47726;
        D.47874 = D.47873 + 1;
        cfg->num_bblocks = D.47874;
        D.47875 = (int) D.47873;
        falsebb->block_num = D.47875;
        D.47866 = ins->data.op[1].many_blocks;
        D.47867 = D.47866 + 8;
        *D.47867 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        D.47842 = falsebb->cil_code;
        if (D.47842 != 0B) goto <D.47876>; else goto <D.47877>;
        <D.47876>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47842 = falsebb->cil_code;
        D.47845 = (long int) D.47842;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47846 = D.47845 - D.47765;
        D.47847 = (long unsigned int) D.47846;
        D.47848 = D.47847 * 8;
        D.47849 = D.47762 + D.47848;
        *D.47849 = falsebb;
        <D.47877>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47881>; else goto <D.47878>;
        <D.47881>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47879>; else goto <D.47882>;
        <D.47882>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47879>; else goto <D.47883>;
        <D.47883>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47879>; else goto <D.47878>;
        <D.47879>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47884>; else goto <D.47878>;
        <D.47884>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47880>;
        <D.47878>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47885>; else goto <D.47887>;
        <D.47887>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47888>; else goto <D.47886>;
        <D.47888>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47889>; else goto <D.47886>;
        <D.47889>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47890>; else goto <D.47886>;
        <D.47890>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47891>; else goto <D.47886>;
        <D.47891>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47885>; else goto <D.47886>;
        <D.47885>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47886>:
        <D.47880>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47892>;
        <D.47872>:
        D.47742 = cfg->cbb;
        D.47742->extended = 1;
        <D.47892>:
        <D.47864>:
      }
      D.47893 = alloc_dreg (cfg, 5);
      addr_reg = (int) D.47893;
      D.47725 = cfg->mempool;
      addr = mono_mempool_alloc (D.47725, 80);
      addr->data.op[1].const_val = 0;
      D.47894 = addr->data.op[1].const_val;
      addr->data.op[0].const_val = D.47894;
      addr->prev = 0B;
      D.47895 = addr->prev;
      addr->next = D.47895;
      addr->opcode = 429;
      addr->flags = 0;
      addr->type = 0;
      addr->dreg = -1;
      addr->sreg3 = -1;
      D.47896 = addr->sreg3;
      addr->sreg2 = D.47896;
      D.47897 = addr->sreg2;
      addr->sreg1 = D.47897;
      D.47740 = cfg->ip;
      addr->cil_code = D.47740;
      addr->dreg = addr_reg;
      obj.440 = obj;
      D.47898 = obj.440->dreg;
      addr->sreg1 = D.47898;
      addr->data.op[1].const_val = 16;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.47899>; else goto <D.47900>;
      <D.47899>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47743->next = addr;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      addr->prev = D.47743;
      D.47742 = cfg->cbb;
      D.47742->last_ins = addr;
      goto <D.47901>;
      <D.47900>:
      D.47742 = cfg->cbb;
      D.47742 = cfg->cbb;
      D.47742->last_ins = addr;
      D.47743 = D.47742->last_ins;
      D.47742->code = D.47743;
      <D.47901>:
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.47725 = cfg->mempool;
        ins = mono_mempool_alloc (D.47725, 80);
        ins->data.op[1].const_val = 0;
        D.47902 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.47902;
        ins->prev = 0B;
        D.47903 = ins->prev;
        ins->next = D.47903;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.47904 = ins->sreg3;
        ins->sreg2 = D.47904;
        D.47905 = ins->sreg2;
        ins->sreg1 = D.47905;
        D.47740 = cfg->ip;
        ins->cil_code = D.47740;
        if (1 != 0) goto <D.47906>; else goto <D.47907>;
        <D.47906>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47908 = D.47726;
        D.47909 = D.47908 + 1;
        cfg->num_bblocks = D.47909;
        D.47910 = (int) D.47908;
        falsebb->block_num = D.47910;
        ins->data.op[0].target_block = end_bb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47911>; else goto <D.47912>;
        <D.47911>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47913>;
        <D.47912>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47913>:
        D.47914 = falsebb->cil_code;
        if (D.47914 != 0B) goto <D.47915>; else goto <D.47916>;
        <D.47915>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47914 = falsebb->cil_code;
        D.47917 = (long int) D.47914;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47918 = D.47917 - D.47765;
        D.47919 = (long unsigned int) D.47918;
        D.47920 = D.47919 * 8;
        D.47921 = D.47762 + D.47920;
        *D.47921 = falsebb;
        <D.47916>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47925>; else goto <D.47922>;
        <D.47925>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47923>; else goto <D.47926>;
        <D.47926>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47923>; else goto <D.47927>;
        <D.47927>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47923>; else goto <D.47922>;
        <D.47923>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47928>; else goto <D.47922>;
        <D.47928>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47924>;
        <D.47922>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47929>; else goto <D.47931>;
        <D.47931>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47932>; else goto <D.47930>;
        <D.47932>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47933>; else goto <D.47930>;
        <D.47933>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47934>; else goto <D.47930>;
        <D.47934>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47935>; else goto <D.47930>;
        <D.47935>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47929>; else goto <D.47930>;
        <D.47929>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47930>:
        <D.47924>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47936>;
        <D.47907>:
        D.47725 = cfg->mempool;
        D.47937 = mono_mempool_alloc (D.47725, 16);
        ins->data.op[1].many_blocks = D.47937;
        D.47938 = ins->data.op[1].many_blocks;
        *D.47938 = end_bb;
        D.47938 = ins->data.op[1].many_blocks;
        D.47939 = D.47938 + 8;
        *D.47939 = 0B;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47940>; else goto <D.47941>;
        <D.47940>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.47942>;
        <D.47941>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.47942>:
        D.47799 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47800 = D.47799 & 34359738368;
        if (D.47800 == 0) goto <D.47943>; else goto <D.47944>;
        <D.47943>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.47945 = D.47726;
        D.47946 = D.47945 + 1;
        cfg->num_bblocks = D.47946;
        D.47947 = (int) D.47945;
        falsebb->block_num = D.47947;
        D.47938 = ins->data.op[1].many_blocks;
        D.47939 = D.47938 + 8;
        *D.47939 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        D.47914 = falsebb->cil_code;
        if (D.47914 != 0B) goto <D.47948>; else goto <D.47949>;
        <D.47948>:
        D.47762 = cfg->cil_offset_to_bb;
        D.47914 = falsebb->cil_code;
        D.47917 = (long int) D.47914;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.47918 = D.47917 - D.47765;
        D.47919 = (long unsigned int) D.47918;
        D.47920 = D.47919 * 8;
        D.47921 = D.47762 + D.47920;
        *D.47921 = falsebb;
        <D.47949>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.47953>; else goto <D.47950>;
        <D.47953>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.47951>; else goto <D.47954>;
        <D.47954>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.47951>; else goto <D.47955>;
        <D.47955>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.47951>; else goto <D.47950>;
        <D.47951>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.47956>; else goto <D.47950>;
        <D.47956>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.47952>;
        <D.47950>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.47957>; else goto <D.47959>;
        <D.47959>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.47960>; else goto <D.47958>;
        <D.47960>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.47961>; else goto <D.47958>;
        <D.47961>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.47962>; else goto <D.47958>;
        <D.47962>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.47963>; else goto <D.47958>;
        <D.47963>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.47957>; else goto <D.47958>;
        <D.47957>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.47958>:
        <D.47952>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.47964>;
        <D.47944>:
        D.47742 = cfg->cbb;
        D.47742->extended = 1;
        <D.47964>:
        <D.47936>:
      }
      D.47965 = is_ref_bb->cil_code;
      if (D.47965 != 0B) goto <D.47966>; else goto <D.47967>;
      <D.47966>:
      D.47762 = cfg->cil_offset_to_bb;
      D.47965 = is_ref_bb->cil_code;
      D.47968 = (long int) D.47965;
      D.47764 = cfg->cil_start;
      D.47765 = (long int) D.47764;
      D.47969 = D.47968 - D.47765;
      D.47970 = (long unsigned int) D.47969;
      D.47971 = D.47970 * 8;
      D.47972 = D.47762 + D.47971;
      *D.47972 = is_ref_bb;
      <D.47967>:
      D.47770 = cfg->real_offset;
      is_ref_bb->real_offset = D.47770;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.47976>; else goto <D.47973>;
      <D.47976>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 <= 9) goto <D.47974>; else goto <D.47977>;
      <D.47977>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 <= 9) goto <D.47974>; else goto <D.47978>;
      <D.47978>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 <= 9) goto <D.47974>; else goto <D.47973>;
      <D.47974>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      D.47783 = *D.47782;
      if (D.47783 == 0B) goto <D.47979>; else goto <D.47973>;
      <D.47979>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      *D.47782 = is_ref_bb;
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, is_ref_bb);
      goto <D.47975>;
      <D.47973>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 == 0B) goto <D.47980>; else goto <D.47982>;
      <D.47982>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 442) goto <D.47983>; else goto <D.47981>;
      <D.47983>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 759) goto <D.47984>; else goto <D.47981>;
      <D.47984>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 > 9) goto <D.47985>; else goto <D.47981>;
      <D.47985>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 > 9) goto <D.47986>; else goto <D.47981>;
      <D.47986>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 > 9) goto <D.47980>; else goto <D.47981>;
      <D.47980>:
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, is_ref_bb);
      <D.47981>:
      <D.47975>:
      D.47742 = cfg->cbb;
      D.47742->next_bb = is_ref_bb;
      cfg->cbb = is_ref_bb;
      D.47987 = alloc_ireg (cfg);
      dreg = (int) D.47987;
      {
        struct MonoInst * var;

        dreg.443 = (unsigned int) dreg;
        D.47990 = cfg->vreg_to_inst_len;
        if (dreg.443 < D.47990) goto <D.47991>; else goto <D.47992>;
        <D.47991>:
        D.47993 = cfg->vreg_to_inst;
        D.47994 = (long unsigned int) dreg;
        D.47995 = D.47994 * 8;
        D.47996 = D.47993 + D.47995;
        iftmp.442 = *D.47996;
        goto <D.47997>;
        <D.47992>:
        iftmp.442 = 0B;
        <D.47997>:
        var = iftmp.442;
        if (var == 0B) goto <D.47998>; else goto <D.47999>;
        <D.47998>:
        D.48000 = &klass->byval_arg;
        var = mono_compile_create_var_for_vreg (cfg, D.48000, 329, dreg);
        <D.47999>:
        D.47725 = cfg->mempool;
        addr = mono_mempool_alloc (D.47725, 80);
        addr->data.op[1].const_val = 0;
        D.47894 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.47894;
        addr->prev = 0B;
        D.47895 = addr->prev;
        addr->next = D.47895;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.47896 = addr->sreg3;
        addr->sreg2 = D.47896;
        D.47897 = addr->sreg2;
        addr->sreg1 = D.47897;
        D.47740 = cfg->ip;
        addr->cil_code = D.47740;
        addr->data.op[0].p = var;
        D.48001 = var->flags;
        D.48002 = D.48001 | 16;
        var->flags = D.48002;
        addr->type = 5;
        D.48003 = var->klass;
        addr->klass = D.48003;
        D.48004 = alloc_dreg (cfg, 5);
        D.48005 = (int) D.48004;
        addr->dreg = D.48005;
        cfg->has_indirection = 1;
        D.48006 = cfg->gsharedvt;
        D.48007 = D.48006 != 0;
        D.48008 = (long int) D.48007;
        D.48009 = __builtin_expect (D.48008, 0);
        if (D.48009 != 0) goto <D.48010>; else goto <D.48011>;
        <D.48010>:
        D.48012 = var->data.op[1].vtype;
        D.48013 = mini_is_gsharedvt_variable_type (cfg, D.48012);
        if (D.48013 != 0) goto <D.48014>; else goto <D.48015>;
        <D.48014>:
        handle_gsharedvt_ldaddr (cfg);
        <D.48015>:
        <D.48011>:
        if (0 != 0) goto <D.48016>; else goto <D.48017>;
        <D.48016>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.48019 = var->dreg;
          D.48020 = D.48019 + 1;
          D.48021 = (unsigned int) D.48020;
          D.47990 = cfg->vreg_to_inst_len;
          if (D.48021 < D.47990) goto <D.48022>; else goto <D.48023>;
          <D.48022>:
          D.47993 = cfg->vreg_to_inst;
          D.48019 = var->dreg;
          D.48024 = (sizetype) D.48019;
          D.48025 = D.48024 + 1;
          D.48026 = D.48025 * 8;
          D.48027 = D.47993 + D.48026;
          iftmp.444 = *D.48027;
          goto <D.48028>;
          <D.48023>:
          iftmp.444 = 0B;
          <D.48028>:
          var1 = iftmp.444;
          D.48019 = var->dreg;
          D.48030 = D.48019 + 2;
          D.48031 = (unsigned int) D.48030;
          D.47990 = cfg->vreg_to_inst_len;
          if (D.48031 < D.47990) goto <D.48032>; else goto <D.48033>;
          <D.48032>:
          D.47993 = cfg->vreg_to_inst;
          D.48019 = var->dreg;
          D.48024 = (sizetype) D.48019;
          D.48034 = D.48024 + 2;
          D.48035 = D.48034 * 8;
          D.48036 = D.47993 + D.48035;
          iftmp.445 = *D.48036;
          goto <D.48037>;
          <D.48033>:
          iftmp.445 = 0B;
          <D.48037>:
          var2 = iftmp.445;
          D.48038 = var1 == 0B;
          D.48039 = (long int) D.48038;
          D.48040 = __builtin_expect (D.48039, 0);
          if (D.48040 != 0) goto <D.48041>; else goto <D.48042>;
          <D.48041>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3684, "var1");
          <D.48042>:
          D.48043 = var2 == 0B;
          D.48044 = (long int) D.48043;
          D.48045 = __builtin_expect (D.48044, 0);
          if (D.48045 != 0) goto <D.48046>; else goto <D.48047>;
          <D.48046>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3684, "var2");
          <D.48047>:
          D.48048 = var1->flags;
          D.48049 = D.48048 | 16;
          var1->flags = D.48049;
          D.48050 = var2->flags;
          D.48051 = D.48050 | 16;
          var2->flags = D.48051;
        }
        <D.48017>:
      }
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.48052>; else goto <D.48053>;
      <D.48052>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47743->next = addr;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      addr->prev = D.47743;
      D.47742 = cfg->cbb;
      D.47742->last_ins = addr;
      goto <D.48054>;
      <D.48053>:
      D.47742 = cfg->cbb;
      D.47742 = cfg->cbb;
      D.47742->last_ins = addr;
      D.47743 = D.47742->last_ins;
      D.47742->code = D.47743;
      <D.48054>:
      addr->dreg = addr_reg;
      {
        struct MonoInst * inst;

        D.47725 = cfg->mempool;
        inst = mono_mempool_alloc (D.47725, 80);
        inst->data.op[1].const_val = 0;
        D.48055 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48055;
        inst->prev = 0B;
        D.48056 = inst->prev;
        inst->next = D.48056;
        inst->opcode = 374;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48057 = inst->sreg3;
        inst->sreg2 = D.48057;
        D.48058 = inst->sreg2;
        inst->sreg1 = D.48058;
        D.47740 = cfg->ip;
        inst->cil_code = D.47740;
        obj.440 = obj;
        D.47898 = obj.440->dreg;
        inst->sreg1 = D.47898;
        D.48059 = addr->dreg;
        inst->dreg = D.48059;
        inst->data.op[0].const_val = 0;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48060>; else goto <D.48061>;
        <D.48060>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = inst;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        inst->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        goto <D.48062>;
        <D.48061>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = inst;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48062>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.47725 = cfg->mempool;
        ins = mono_mempool_alloc (D.47725, 80);
        ins->data.op[1].const_val = 0;
        D.48063 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.48063;
        ins->prev = 0B;
        D.48064 = ins->prev;
        ins->next = D.48064;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.48065 = ins->sreg3;
        ins->sreg2 = D.48065;
        D.48066 = ins->sreg2;
        ins->sreg1 = D.48066;
        D.47740 = cfg->ip;
        ins->cil_code = D.47740;
        if (1 != 0) goto <D.48067>; else goto <D.48068>;
        <D.48067>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.48069 = D.47726;
        D.48070 = D.48069 + 1;
        cfg->num_bblocks = D.48070;
        D.48071 = (int) D.48069;
        falsebb->block_num = D.48071;
        ins->data.op[0].target_block = end_bb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48072>; else goto <D.48073>;
        <D.48072>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.48074>;
        <D.48073>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48074>:
        D.48075 = falsebb->cil_code;
        if (D.48075 != 0B) goto <D.48076>; else goto <D.48077>;
        <D.48076>:
        D.47762 = cfg->cil_offset_to_bb;
        D.48075 = falsebb->cil_code;
        D.48078 = (long int) D.48075;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.48079 = D.48078 - D.47765;
        D.48080 = (long unsigned int) D.48079;
        D.48081 = D.48080 * 8;
        D.48082 = D.47762 + D.48081;
        *D.48082 = falsebb;
        <D.48077>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48086>; else goto <D.48083>;
        <D.48086>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.48084>; else goto <D.48087>;
        <D.48087>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.48084>; else goto <D.48088>;
        <D.48088>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.48084>; else goto <D.48083>;
        <D.48084>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.48089>; else goto <D.48083>;
        <D.48089>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.48085>;
        <D.48083>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.48090>; else goto <D.48092>;
        <D.48092>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.48093>; else goto <D.48091>;
        <D.48093>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.48094>; else goto <D.48091>;
        <D.48094>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.48095>; else goto <D.48091>;
        <D.48095>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.48096>; else goto <D.48091>;
        <D.48096>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.48090>; else goto <D.48091>;
        <D.48090>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.48091>:
        <D.48085>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.48097>;
        <D.48068>:
        D.47725 = cfg->mempool;
        D.48098 = mono_mempool_alloc (D.47725, 16);
        ins->data.op[1].many_blocks = D.48098;
        D.48099 = ins->data.op[1].many_blocks;
        *D.48099 = end_bb;
        D.48099 = ins->data.op[1].many_blocks;
        D.48100 = D.48099 + 8;
        *D.48100 = 0B;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48101>; else goto <D.48102>;
        <D.48101>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.48103>;
        <D.48102>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48103>:
        D.47799 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47800 = D.47799 & 34359738368;
        if (D.47800 == 0) goto <D.48104>; else goto <D.48105>;
        <D.48104>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.48106 = D.47726;
        D.48107 = D.48106 + 1;
        cfg->num_bblocks = D.48107;
        D.48108 = (int) D.48106;
        falsebb->block_num = D.48108;
        D.48099 = ins->data.op[1].many_blocks;
        D.48100 = D.48099 + 8;
        *D.48100 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        D.48075 = falsebb->cil_code;
        if (D.48075 != 0B) goto <D.48109>; else goto <D.48110>;
        <D.48109>:
        D.47762 = cfg->cil_offset_to_bb;
        D.48075 = falsebb->cil_code;
        D.48078 = (long int) D.48075;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.48079 = D.48078 - D.47765;
        D.48080 = (long unsigned int) D.48079;
        D.48081 = D.48080 * 8;
        D.48082 = D.47762 + D.48081;
        *D.48082 = falsebb;
        <D.48110>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48114>; else goto <D.48111>;
        <D.48114>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.48112>; else goto <D.48115>;
        <D.48115>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.48112>; else goto <D.48116>;
        <D.48116>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.48112>; else goto <D.48111>;
        <D.48112>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.48117>; else goto <D.48111>;
        <D.48117>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.48113>;
        <D.48111>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.48118>; else goto <D.48120>;
        <D.48120>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.48121>; else goto <D.48119>;
        <D.48121>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.48122>; else goto <D.48119>;
        <D.48122>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.48123>; else goto <D.48119>;
        <D.48123>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.48124>; else goto <D.48119>;
        <D.48124>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.48118>; else goto <D.48119>;
        <D.48118>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.48119>:
        <D.48113>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.48125>;
        <D.48105>:
        D.47742 = cfg->cbb;
        D.47742->extended = 1;
        <D.48125>:
        <D.48097>:
      }
      D.48126 = is_nullable_bb->cil_code;
      if (D.48126 != 0B) goto <D.48127>; else goto <D.48128>;
      <D.48127>:
      D.47762 = cfg->cil_offset_to_bb;
      D.48126 = is_nullable_bb->cil_code;
      D.48129 = (long int) D.48126;
      D.47764 = cfg->cil_start;
      D.47765 = (long int) D.47764;
      D.48130 = D.48129 - D.47765;
      D.48131 = (long unsigned int) D.48130;
      D.48132 = D.48131 * 8;
      D.48133 = D.47762 + D.48132;
      *D.48133 = is_nullable_bb;
      <D.48128>:
      D.47770 = cfg->real_offset;
      is_nullable_bb->real_offset = D.47770;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.48137>; else goto <D.48134>;
      <D.48137>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 <= 9) goto <D.48135>; else goto <D.48138>;
      <D.48138>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 <= 9) goto <D.48135>; else goto <D.48139>;
      <D.48139>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 <= 9) goto <D.48135>; else goto <D.48134>;
      <D.48135>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      D.47783 = *D.47782;
      if (D.47783 == 0B) goto <D.48140>; else goto <D.48134>;
      <D.48140>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      *D.47782 = is_nullable_bb;
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, is_nullable_bb);
      goto <D.48136>;
      <D.48134>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 == 0B) goto <D.48141>; else goto <D.48143>;
      <D.48143>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 442) goto <D.48144>; else goto <D.48142>;
      <D.48144>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 759) goto <D.48145>; else goto <D.48142>;
      <D.48145>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 > 9) goto <D.48146>; else goto <D.48142>;
      <D.48146>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 > 9) goto <D.48147>; else goto <D.48142>;
      <D.48147>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 > 9) goto <D.48141>; else goto <D.48142>;
      <D.48141>:
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, is_nullable_bb);
      <D.48142>:
      <D.48136>:
      D.47742 = cfg->cbb;
      D.47742->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.48000 = &klass->byval_arg;
        var = mono_compile_create_var (cfg, D.48000, 329);
        D.47725 = cfg->mempool;
        unbox_sig = mono_mempool_alloc0 (D.47725, 24);
        D.48000 = &klass->byval_arg;
        unbox_sig->ret = D.48000;
        unbox_sig->param_count = 1;
        D.48148 = mono_defaults.object_class;
        D.48149 = &D.48148->byval_arg;
        unbox_sig->params[0] = D.48149;
        unbox_call = mono_emit_calli (cfg, unbox_sig, &obj, addr, 0B, 0B);
        {
          struct MonoInst * var;

          D.48151 = unbox_call->dreg;
          D.48152 = (unsigned int) D.48151;
          D.47990 = cfg->vreg_to_inst_len;
          if (D.48152 < D.47990) goto <D.48153>; else goto <D.48154>;
          <D.48153>:
          D.47993 = cfg->vreg_to_inst;
          D.48151 = unbox_call->dreg;
          D.48155 = (long unsigned int) D.48151;
          D.48156 = D.48155 * 8;
          D.48157 = D.47993 + D.48156;
          iftmp.446 = *D.48157;
          goto <D.48158>;
          <D.48154>:
          iftmp.446 = 0B;
          <D.48158>:
          var = iftmp.446;
          if (var == 0B) goto <D.48159>; else goto <D.48160>;
          <D.48159>:
          D.48000 = &klass->byval_arg;
          D.48151 = unbox_call->dreg;
          var = mono_compile_create_var_for_vreg (cfg, D.48000, 329, D.48151);
          <D.48160>:
          D.47725 = cfg->mempool;
          addr = mono_mempool_alloc (D.47725, 80);
          addr->data.op[1].const_val = 0;
          D.48161 = addr->data.op[1].const_val;
          addr->data.op[0].const_val = D.48161;
          addr->prev = 0B;
          D.48162 = addr->prev;
          addr->next = D.48162;
          addr->opcode = 314;
          addr->flags = 0;
          addr->type = 0;
          addr->dreg = -1;
          addr->sreg3 = -1;
          D.48163 = addr->sreg3;
          addr->sreg2 = D.48163;
          D.48164 = addr->sreg2;
          addr->sreg1 = D.48164;
          D.47740 = cfg->ip;
          addr->cil_code = D.47740;
          addr->data.op[0].p = var;
          D.48165 = var->flags;
          D.48166 = D.48165 | 16;
          var->flags = D.48166;
          addr->type = 5;
          D.48167 = var->klass;
          addr->klass = D.48167;
          D.48168 = alloc_dreg (cfg, 5);
          D.48169 = (int) D.48168;
          addr->dreg = D.48169;
          cfg->has_indirection = 1;
          D.48006 = cfg->gsharedvt;
          D.48007 = D.48006 != 0;
          D.48008 = (long int) D.48007;
          D.48009 = __builtin_expect (D.48008, 0);
          if (D.48009 != 0) goto <D.48170>; else goto <D.48171>;
          <D.48170>:
          D.48172 = var->data.op[1].vtype;
          D.48173 = mini_is_gsharedvt_variable_type (cfg, D.48172);
          if (D.48173 != 0) goto <D.48174>; else goto <D.48175>;
          <D.48174>:
          handle_gsharedvt_ldaddr (cfg);
          <D.48175>:
          <D.48171>:
          if (0 != 0) goto <D.48176>; else goto <D.48177>;
          <D.48176>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.48179 = var->dreg;
            D.48180 = D.48179 + 1;
            D.48181 = (unsigned int) D.48180;
            D.47990 = cfg->vreg_to_inst_len;
            if (D.48181 < D.47990) goto <D.48182>; else goto <D.48183>;
            <D.48182>:
            D.47993 = cfg->vreg_to_inst;
            D.48179 = var->dreg;
            D.48184 = (sizetype) D.48179;
            D.48185 = D.48184 + 1;
            D.48186 = D.48185 * 8;
            D.48187 = D.47993 + D.48186;
            iftmp.447 = *D.48187;
            goto <D.48188>;
            <D.48183>:
            iftmp.447 = 0B;
            <D.48188>:
            var1 = iftmp.447;
            D.48179 = var->dreg;
            D.48190 = D.48179 + 2;
            D.48191 = (unsigned int) D.48190;
            D.47990 = cfg->vreg_to_inst_len;
            if (D.48191 < D.47990) goto <D.48192>; else goto <D.48193>;
            <D.48192>:
            D.47993 = cfg->vreg_to_inst;
            D.48179 = var->dreg;
            D.48184 = (sizetype) D.48179;
            D.48194 = D.48184 + 2;
            D.48195 = D.48194 * 8;
            D.48196 = D.47993 + D.48195;
            iftmp.448 = *D.48196;
            goto <D.48197>;
            <D.48193>:
            iftmp.448 = 0B;
            <D.48197>:
            var2 = iftmp.448;
            D.48198 = var1 == 0B;
            D.48199 = (long int) D.48198;
            D.48200 = __builtin_expect (D.48199, 0);
            if (D.48200 != 0) goto <D.48201>; else goto <D.48202>;
            <D.48201>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3706, "var1");
            <D.48202>:
            D.48203 = var2 == 0B;
            D.48204 = (long int) D.48203;
            D.48205 = __builtin_expect (D.48204, 0);
            if (D.48205 != 0) goto <D.48206>; else goto <D.48207>;
            <D.48206>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3706, "var2");
            <D.48207>:
            D.48208 = var1->flags;
            D.48209 = D.48208 | 16;
            var1->flags = D.48209;
            D.48210 = var2->flags;
            D.48211 = D.48210 | 16;
            var2->flags = D.48211;
          }
          <D.48177>:
        }
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48212>; else goto <D.48213>;
        <D.48212>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = addr;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        addr->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = addr;
        goto <D.48214>;
        <D.48213>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = addr;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48214>:
        addr->dreg = addr_reg;
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.47725 = cfg->mempool;
        ins = mono_mempool_alloc (D.47725, 80);
        ins->data.op[1].const_val = 0;
        D.48215 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.48215;
        ins->prev = 0B;
        D.48216 = ins->prev;
        ins->next = D.48216;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.48217 = ins->sreg3;
        ins->sreg2 = D.48217;
        D.48218 = ins->sreg2;
        ins->sreg1 = D.48218;
        D.47740 = cfg->ip;
        ins->cil_code = D.47740;
        if (1 != 0) goto <D.48219>; else goto <D.48220>;
        <D.48219>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.48221 = D.47726;
        D.48222 = D.48221 + 1;
        cfg->num_bblocks = D.48222;
        D.48223 = (int) D.48221;
        falsebb->block_num = D.48223;
        ins->data.op[0].target_block = end_bb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48224>; else goto <D.48225>;
        <D.48224>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.48226>;
        <D.48225>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48226>:
        D.48227 = falsebb->cil_code;
        if (D.48227 != 0B) goto <D.48228>; else goto <D.48229>;
        <D.48228>:
        D.47762 = cfg->cil_offset_to_bb;
        D.48227 = falsebb->cil_code;
        D.48230 = (long int) D.48227;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.48231 = D.48230 - D.47765;
        D.48232 = (long unsigned int) D.48231;
        D.48233 = D.48232 * 8;
        D.48234 = D.47762 + D.48233;
        *D.48234 = falsebb;
        <D.48229>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48238>; else goto <D.48235>;
        <D.48238>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.48236>; else goto <D.48239>;
        <D.48239>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.48236>; else goto <D.48240>;
        <D.48240>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.48236>; else goto <D.48235>;
        <D.48236>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.48241>; else goto <D.48235>;
        <D.48241>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.48237>;
        <D.48235>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.48242>; else goto <D.48244>;
        <D.48244>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.48245>; else goto <D.48243>;
        <D.48245>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.48246>; else goto <D.48243>;
        <D.48246>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.48247>; else goto <D.48243>;
        <D.48247>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.48248>; else goto <D.48243>;
        <D.48248>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.48242>; else goto <D.48243>;
        <D.48242>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.48243>:
        <D.48237>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.48249>;
        <D.48220>:
        D.47725 = cfg->mempool;
        D.48250 = mono_mempool_alloc (D.47725, 16);
        ins->data.op[1].many_blocks = D.48250;
        D.48251 = ins->data.op[1].many_blocks;
        *D.48251 = end_bb;
        D.48251 = ins->data.op[1].many_blocks;
        D.48252 = D.48251 + 8;
        *D.48252 = 0B;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, end_bb);
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48253>; else goto <D.48254>;
        <D.48253>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47743->next = ins;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        ins->prev = D.47743;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        goto <D.48255>;
        <D.48254>:
        D.47742 = cfg->cbb;
        D.47742 = cfg->cbb;
        D.47742->last_ins = ins;
        D.47743 = D.47742->last_ins;
        D.47742->code = D.47743;
        <D.48255>:
        D.47799 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47800 = D.47799 & 34359738368;
        if (D.47800 == 0) goto <D.48256>; else goto <D.48257>;
        <D.48256>:
        D.47725 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.47725, 296);
        D.47726 = cfg->num_bblocks;
        D.48258 = D.47726;
        D.48259 = D.48258 + 1;
        cfg->num_bblocks = D.48259;
        D.48260 = (int) D.48258;
        falsebb->block_num = D.48260;
        D.48251 = ins->data.op[1].many_blocks;
        D.48252 = D.48251 + 8;
        *D.48252 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        D.48227 = falsebb->cil_code;
        if (D.48227 != 0B) goto <D.48261>; else goto <D.48262>;
        <D.48261>:
        D.47762 = cfg->cil_offset_to_bb;
        D.48227 = falsebb->cil_code;
        D.48230 = (long int) D.48227;
        D.47764 = cfg->cil_start;
        D.47765 = (long int) D.47764;
        D.48231 = D.48230 - D.47765;
        D.48232 = (long unsigned int) D.48231;
        D.48233 = D.48232 * 8;
        D.48234 = D.47762 + D.48233;
        *D.48234 = falsebb;
        <D.48262>:
        D.47770 = cfg->real_offset;
        falsebb->real_offset = D.47770;
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 != 0B) goto <D.48266>; else goto <D.48263>;
        <D.48266>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 <= 9) goto <D.48264>; else goto <D.48267>;
        <D.48267>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 <= 9) goto <D.48264>; else goto <D.48268>;
        <D.48268>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 <= 9) goto <D.48264>; else goto <D.48263>;
        <D.48264>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        D.47783 = *D.47782;
        if (D.47783 == 0B) goto <D.48269>; else goto <D.48263>;
        <D.48269>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47781 = D.47743->data.op[1].many_blocks;
        D.47782 = D.47781 + 8;
        *D.47782 = falsebb;
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        goto <D.48265>;
        <D.48263>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        if (D.47743 == 0B) goto <D.48270>; else goto <D.48272>;
        <D.48272>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 442) goto <D.48273>; else goto <D.48271>;
        <D.48273>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        if (D.47775 != 759) goto <D.48274>; else goto <D.48271>;
        <D.48274>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47776 = D.47775 + 64985;
        if (D.47776 > 9) goto <D.48275>; else goto <D.48271>;
        <D.48275>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47778 = D.47775 + 64878;
        if (D.47778 > 9) goto <D.48276>; else goto <D.48271>;
        <D.48276>:
        D.47742 = cfg->cbb;
        D.47743 = D.47742->last_ins;
        D.47775 = D.47743->opcode;
        D.47780 = D.47775 + 64888;
        if (D.47780 > 9) goto <D.48270>; else goto <D.48271>;
        <D.48270>:
        D.47742 = cfg->cbb;
        mono_link_bblock (cfg, D.47742, falsebb);
        <D.48271>:
        <D.48265>:
        D.47742 = cfg->cbb;
        D.47742->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.48277>;
        <D.48257>:
        D.47742 = cfg->cbb;
        D.47742->extended = 1;
        <D.48277>:
        <D.48249>:
      }
      D.48278 = end_bb->cil_code;
      if (D.48278 != 0B) goto <D.48279>; else goto <D.48280>;
      <D.48279>:
      D.47762 = cfg->cil_offset_to_bb;
      D.48278 = end_bb->cil_code;
      D.48281 = (long int) D.48278;
      D.47764 = cfg->cil_start;
      D.47765 = (long int) D.47764;
      D.48282 = D.48281 - D.47765;
      D.48283 = (long unsigned int) D.48282;
      D.48284 = D.48283 * 8;
      D.48285 = D.47762 + D.48284;
      *D.48285 = end_bb;
      <D.48280>:
      D.47770 = cfg->real_offset;
      end_bb->real_offset = D.47770;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.48289>; else goto <D.48286>;
      <D.48289>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 <= 9) goto <D.48287>; else goto <D.48290>;
      <D.48290>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 <= 9) goto <D.48287>; else goto <D.48291>;
      <D.48291>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 <= 9) goto <D.48287>; else goto <D.48286>;
      <D.48287>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      D.47783 = *D.47782;
      if (D.47783 == 0B) goto <D.48292>; else goto <D.48286>;
      <D.48292>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47781 = D.47743->data.op[1].many_blocks;
      D.47782 = D.47781 + 8;
      *D.47782 = end_bb;
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, end_bb);
      goto <D.48288>;
      <D.48286>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 == 0B) goto <D.48293>; else goto <D.48295>;
      <D.48295>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 442) goto <D.48296>; else goto <D.48294>;
      <D.48296>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      if (D.47775 != 759) goto <D.48297>; else goto <D.48294>;
      <D.48297>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47776 = D.47775 + 64985;
      if (D.47776 > 9) goto <D.48298>; else goto <D.48294>;
      <D.48298>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47778 = D.47775 + 64878;
      if (D.47778 > 9) goto <D.48299>; else goto <D.48294>;
      <D.48299>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47775 = D.47743->opcode;
      D.47780 = D.47775 + 64888;
      if (D.47780 > 9) goto <D.48293>; else goto <D.48294>;
      <D.48293>:
      D.47742 = cfg->cbb;
      mono_link_bblock (cfg, D.47742, end_bb);
      <D.48294>:
      <D.48288>:
      D.47742 = cfg->cbb;
      D.47742->next_bb = end_bb;
      cfg->cbb = end_bb;
      D.47725 = cfg->mempool;
      ins = mono_mempool_alloc (D.47725, 80);
      ins->data.op[1].const_val = 0;
      D.48300 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.48300;
      ins->prev = 0B;
      D.48301 = ins->prev;
      ins->next = D.48301;
      D.48000 = &klass->byval_arg;
      D.48302 = mono_type_to_load_membase (cfg, D.48000);
      D.48303 = (short unsigned int) D.48302;
      ins->opcode = D.48303;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.48304 = ins->sreg3;
      ins->sreg2 = D.48304;
      D.48305 = ins->sreg2;
      ins->sreg1 = D.48305;
      D.47740 = cfg->ip;
      ins->cil_code = D.47740;
      ins->dreg = 0;
      ins->sreg1 = addr_reg;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      D.48000 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.48000, ins);
      D.48306 = ins->type;
      D.48307 = (<unnamed type>) D.48306;
      D.48308 = alloc_dreg (cfg, D.48307);
      D.48309 = (int) D.48308;
      ins->dreg = D.48309;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      if (D.47743 != 0B) goto <D.48310>; else goto <D.48311>;
      <D.48310>:
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      D.47743->next = ins;
      D.47742 = cfg->cbb;
      D.47743 = D.47742->last_ins;
      ins->prev = D.47743;
      D.47742 = cfg->cbb;
      D.47742->last_ins = ins;
      goto <D.48312>;
      <D.48311>:
      D.47742 = cfg->cbb;
      D.47742 = cfg->cbb;
      D.47742->last_ins = ins;
      D.47743 = D.47742->last_ins;
      D.47742->code = D.47743;
      <D.48312>:
      D.47742 = cfg->cbb;
      *out_cbb = D.47742;
      D.48313 = ins;
      return D.48313;
    }
  finally
    {
      args = {CLOBBER};
    }
}


mini_class_has_reference_variant_generic_argument (struct MonoCompile * cfg, struct MonoClass * klass, int context_used)
{
  struct MonoGenericClass * D.48316;
  struct MonoClass * D.48319;
  struct MonoGenericContainer * D.48323;
  gboolean D.48326;
  struct MonoGenericParamFull * D.48327;
  long unsigned int D.48328;
  long unsigned int D.48329;
  struct MonoGenericParamFull * D.48330;
  short unsigned int D.48331;
  int D.48332;
  int D.48333;
  int D.48336;
  <unnamed-signed:31> D.48339;
  int D.48340;
  int i;
  struct MonoGenericContainer * container;
  struct MonoGenericInst * ginst;

  D.48316 = klass->generic_class;
  if (D.48316 != 0B) goto <D.48317>; else goto <D.48318>;
  <D.48317>:
  D.48316 = klass->generic_class;
  D.48319 = D.48316->container_class;
  container = D.48319->generic_container;
  D.48316 = klass->generic_class;
  ginst = D.48316->context.class_inst;
  goto <D.48320>;
  <D.48318>:
  D.48323 = klass->generic_container;
  if (D.48323 != 0B) goto <D.48324>; else goto <D.48321>;
  <D.48324>:
  if (context_used != 0) goto <D.48325>; else goto <D.48321>;
  <D.48325>:
  container = klass->generic_container;
  ginst = container->context.class_inst;
  goto <D.48322>;
  <D.48321>:
  D.48326 = 0;
  return D.48326;
  <D.48322>:
  <D.48320>:
  i = 0;
  goto <D.26404>;
  <D.26403>:
  {
    struct MonoType * type;

    D.48327 = container->type_params;
    D.48328 = (long unsigned int) i;
    D.48329 = D.48328 * 56;
    D.48330 = D.48327 + D.48329;
    D.48331 = D.48330->info.flags;
    D.48332 = (int) D.48331;
    D.48333 = D.48332 & 3;
    if (D.48333 == 0) goto <D.48334>; else goto <D.48335>;
    <D.48334>:
    // predicted unlikely by continue predictor.
    goto <D.26402>;
    <D.48335>:
    type = ginst->type_argv[i];
    D.48336 = mini_type_is_reference (cfg, type);
    if (D.48336 != 0) goto <D.48337>; else goto <D.48338>;
    <D.48337>:
    D.48326 = 1;
    return D.48326;
    <D.48338>:
  }
  <D.26402>:
  i = i + 1;
  <D.26404>:
  D.48339 = container->type_argc;
  D.48340 = (int) D.48339;
  if (D.48340 > i) goto <D.26403>; else goto <D.26405>;
  <D.26405>:
  D.48326 = 0;
  return D.48326;
}


handle_castclass (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src, int context_used)
{
  unsigned int D.48342;
  struct MonoMemPool * D.48347;
  void * D.48348;
  struct MonoInst * D.48349;
  long int D.48350;
  struct MonoInst * D.48351;
  int D.48352;
  int D.48353;
  const unsigned char * D.48354;
  unsigned int D.48355;
  int D.48356;
  int D.48357;
  struct MonoBasicBlock * D.48358;
  struct MonoInst * D.48359;
  struct MonoInst * D.48363;
  unsigned int D.48364;
  unsigned int D.48365;
  unsigned int D.48366;
  int D.48367;
  long int D.48368;
  struct MonoInst * D.48369;
  int D.48370;
  int D.48371;
  long int D.48375;
  struct MonoInst * D.48376;
  int D.48377;
  int D.48378;
  unsigned int D.48381;
  unsigned int D.48382;
  int D.48383;
  unsigned char * D.48387;
  struct MonoBasicBlock * * D.48390;
  long int D.48391;
  unsigned char * D.48392;
  long int D.48393;
  long int D.48394;
  long unsigned int D.48395;
  long unsigned int D.48396;
  struct MonoBasicBlock * * D.48397;
  unsigned int D.48398;
  short unsigned int D.48403;
  short unsigned int D.48404;
  short unsigned int D.48406;
  short unsigned int D.48408;
  struct MonoBasicBlock * * D.48409;
  struct MonoBasicBlock * * D.48410;
  struct MonoBasicBlock * D.48411;
  void * D.48421;
  struct MonoBasicBlock * * D.48422;
  struct MonoBasicBlock * * D.48423;
  long unsigned int D.48427;
  long unsigned int D.48428;
  unsigned int D.48431;
  unsigned int D.48432;
  int D.48433;
  unsigned int D.48451;
  unsigned int D.48452;
  long int D.48455;
  struct MonoInst * D.48456;
  int D.48457;
  int D.48458;
  unsigned int D.48463;
  long int D.48464;
  struct MonoInst * D.48465;
  int D.48466;
  int D.48467;
  unsigned char D.48473;
  long unsigned int D.48475;
  unsigned int D.48477;
  unsigned int D.48478;
  unsigned int D.48480;
  struct MonoDomain * D.48484;
  long int D.48487;
  struct MonoInst * D.48488;
  int D.48489;
  int D.48490;
  long int vt.449;
  long int D.48496;
  struct MonoInst * D.48497;
  int D.48498;
  int D.48499;
  long int D.48503;
  struct MonoInst * D.48504;
  int D.48505;
  int D.48506;
  long int klass.450;
  long int D.48511;
  struct MonoInst * D.48512;
  int D.48513;
  int D.48514;
  long int D.48518;
  struct MonoInst * D.48519;
  int D.48520;
  int D.48521;
  unsigned char * D.48525;
  long int D.48528;
  long int D.48529;
  long unsigned int D.48530;
  long unsigned int D.48531;
  struct MonoBasicBlock * * D.48532;
  struct MonoBasicBlock * is_null_bb;
  int obj_reg;
  int vtable_reg;
  struct MonoInst * klass_inst;

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

    try
      {
        mini_class_has_reference_variant_generic_argument (cfg, klass, context_used);
        if (1 != 0) goto <D.48345>; else goto <D.48346>;
        <D.48345>:
        {
          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.48347 = cfg->mempool;
          D.48348 = mono_mempool_alloc (D.48347, 80);
          args[1] = D.48348;
          D.48349 = args[1];
          D.48349 = args[1];
          D.48349->data.op[1].const_val = 0;
          D.48350 = D.48349->data.op[1].const_val;
          D.48349->data.op[0].const_val = D.48350;
          D.48349 = args[1];
          D.48349 = args[1];
          D.48349->prev = 0B;
          D.48351 = D.48349->prev;
          D.48349->next = D.48351;
          D.48349 = args[1];
          D.48349->opcode = 388;
          D.48349 = args[1];
          D.48349->flags = 0;
          D.48349 = args[1];
          D.48349->type = 0;
          D.48349 = args[1];
          D.48349->dreg = -1;
          D.48349 = args[1];
          D.48349 = args[1];
          D.48349 = args[1];
          D.48349->sreg3 = -1;
          D.48352 = D.48349->sreg3;
          D.48349->sreg2 = D.48352;
          D.48353 = D.48349->sreg2;
          D.48349->sreg1 = D.48353;
          D.48349 = args[1];
          D.48354 = cfg->ip;
          D.48349->cil_code = D.48354;
          D.48349 = args[1];
          D.48355 = alloc_preg (cfg);
          D.48356 = (int) D.48355;
          D.48349->dreg = D.48356;
          D.48349 = args[1];
          D.48357 = cache_ins->dreg;
          D.48349->sreg1 = D.48357;
          D.48349 = args[1];
          D.48349->data.op[0].const_val = 8;
          D.48349 = args[1];
          D.48349->type = 1;
          D.48358 = cfg->cbb;
          D.48359 = D.48358->last_ins;
          if (D.48359 != 0B) goto <D.48360>; else goto <D.48361>;
          <D.48360>:
          D.48358 = cfg->cbb;
          D.48359 = D.48358->last_ins;
          D.48349 = args[1];
          D.48359->next = D.48349;
          D.48349 = args[1];
          D.48358 = cfg->cbb;
          D.48359 = D.48358->last_ins;
          D.48349->prev = D.48359;
          D.48358 = cfg->cbb;
          D.48349 = args[1];
          D.48358->last_ins = D.48349;
          goto <D.48362>;
          <D.48361>:
          D.48358 = cfg->cbb;
          D.48358 = cfg->cbb;
          D.48349 = args[1];
          D.48358->last_ins = D.48349;
          D.48359 = D.48358->last_ins;
          D.48358->code = D.48359;
          <D.48362>:
          args[2] = cache_ins;
          D.48363 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
          return D.48363;
        }
        <D.48346>:
        klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, 1);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  <D.48344>:
  D.48347 = cfg->mempool;
  is_null_bb = mono_mempool_alloc0 (D.48347, 296);
  D.48364 = cfg->num_bblocks;
  D.48365 = D.48364;
  D.48366 = D.48365 + 1;
  cfg->num_bblocks = D.48366;
  D.48367 = (int) D.48365;
  is_null_bb->block_num = D.48367;
  {
    struct MonoInst * inst;

    D.48347 = cfg->mempool;
    inst = mono_mempool_alloc (D.48347, 80);
    inst->data.op[1].const_val = 0;
    D.48368 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48368;
    inst->prev = 0B;
    D.48369 = inst->prev;
    inst->next = D.48369;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48370 = inst->sreg3;
    inst->sreg2 = D.48370;
    D.48371 = inst->sreg2;
    inst->sreg1 = D.48371;
    D.48354 = cfg->ip;
    inst->cil_code = D.48354;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48372>; else goto <D.48373>;
    <D.48372>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48359->next = inst;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    inst->prev = D.48359;
    D.48358 = cfg->cbb;
    D.48358->last_ins = inst;
    goto <D.48374>;
    <D.48373>:
    D.48358 = cfg->cbb;
    D.48358 = cfg->cbb;
    D.48358->last_ins = inst;
    D.48359 = D.48358->last_ins;
    D.48358->code = D.48359;
    <D.48374>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48347 = cfg->mempool;
    ins = mono_mempool_alloc (D.48347, 80);
    ins->data.op[1].const_val = 0;
    D.48375 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48375;
    ins->prev = 0B;
    D.48376 = ins->prev;
    ins->next = D.48376;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48377 = ins->sreg3;
    ins->sreg2 = D.48377;
    D.48378 = ins->sreg2;
    ins->sreg1 = D.48378;
    D.48354 = cfg->ip;
    ins->cil_code = D.48354;
    if (0 != 0) goto <D.48379>; else goto <D.48380>;
    <D.48379>:
    D.48347 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48347, 296);
    D.48364 = cfg->num_bblocks;
    D.48381 = D.48364;
    D.48382 = D.48381 + 1;
    cfg->num_bblocks = D.48382;
    D.48383 = (int) D.48381;
    falsebb->block_num = D.48383;
    ins->data.op[0].target_block = is_null_bb;
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, is_null_bb);
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48384>; else goto <D.48385>;
    <D.48384>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48359->next = ins;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    ins->prev = D.48359;
    D.48358 = cfg->cbb;
    D.48358->last_ins = ins;
    goto <D.48386>;
    <D.48385>:
    D.48358 = cfg->cbb;
    D.48358 = cfg->cbb;
    D.48358->last_ins = ins;
    D.48359 = D.48358->last_ins;
    D.48358->code = D.48359;
    <D.48386>:
    D.48387 = falsebb->cil_code;
    if (D.48387 != 0B) goto <D.48388>; else goto <D.48389>;
    <D.48388>:
    D.48390 = cfg->cil_offset_to_bb;
    D.48387 = falsebb->cil_code;
    D.48391 = (long int) D.48387;
    D.48392 = cfg->cil_start;
    D.48393 = (long int) D.48392;
    D.48394 = D.48391 - D.48393;
    D.48395 = (long unsigned int) D.48394;
    D.48396 = D.48395 * 8;
    D.48397 = D.48390 + D.48396;
    *D.48397 = falsebb;
    <D.48389>:
    D.48398 = cfg->real_offset;
    falsebb->real_offset = D.48398;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48402>; else goto <D.48399>;
    <D.48402>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48404 = D.48403 + 64985;
    if (D.48404 <= 9) goto <D.48400>; else goto <D.48405>;
    <D.48405>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48406 = D.48403 + 64878;
    if (D.48406 <= 9) goto <D.48400>; else goto <D.48407>;
    <D.48407>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48408 = D.48403 + 64888;
    if (D.48408 <= 9) goto <D.48400>; else goto <D.48399>;
    <D.48400>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48409 = D.48359->data.op[1].many_blocks;
    D.48410 = D.48409 + 8;
    D.48411 = *D.48410;
    if (D.48411 == 0B) goto <D.48412>; else goto <D.48399>;
    <D.48412>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48409 = D.48359->data.op[1].many_blocks;
    D.48410 = D.48409 + 8;
    *D.48410 = falsebb;
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, falsebb);
    goto <D.48401>;
    <D.48399>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 == 0B) goto <D.48413>; else goto <D.48415>;
    <D.48415>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    if (D.48403 != 442) goto <D.48416>; else goto <D.48414>;
    <D.48416>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    if (D.48403 != 759) goto <D.48417>; else goto <D.48414>;
    <D.48417>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48404 = D.48403 + 64985;
    if (D.48404 > 9) goto <D.48418>; else goto <D.48414>;
    <D.48418>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48406 = D.48403 + 64878;
    if (D.48406 > 9) goto <D.48419>; else goto <D.48414>;
    <D.48419>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48408 = D.48403 + 64888;
    if (D.48408 > 9) goto <D.48413>; else goto <D.48414>;
    <D.48413>:
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, falsebb);
    <D.48414>:
    <D.48401>:
    D.48358 = cfg->cbb;
    D.48358->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48420>;
    <D.48380>:
    D.48347 = cfg->mempool;
    D.48421 = mono_mempool_alloc (D.48347, 16);
    ins->data.op[1].many_blocks = D.48421;
    D.48422 = ins->data.op[1].many_blocks;
    *D.48422 = is_null_bb;
    D.48422 = ins->data.op[1].many_blocks;
    D.48423 = D.48422 + 8;
    *D.48423 = 0B;
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, is_null_bb);
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48424>; else goto <D.48425>;
    <D.48424>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48359->next = ins;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    ins->prev = D.48359;
    D.48358 = cfg->cbb;
    D.48358->last_ins = ins;
    goto <D.48426>;
    <D.48425>:
    D.48358 = cfg->cbb;
    D.48358 = cfg->cbb;
    D.48358->last_ins = ins;
    D.48359 = D.48358->last_ins;
    D.48358->code = D.48359;
    <D.48426>:
    D.48427 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48428 = D.48427 & 34359738368;
    if (D.48428 == 0) goto <D.48429>; else goto <D.48430>;
    <D.48429>:
    D.48347 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48347, 296);
    D.48364 = cfg->num_bblocks;
    D.48431 = D.48364;
    D.48432 = D.48431 + 1;
    cfg->num_bblocks = D.48432;
    D.48433 = (int) D.48431;
    falsebb->block_num = D.48433;
    D.48422 = ins->data.op[1].many_blocks;
    D.48423 = D.48422 + 8;
    *D.48423 = falsebb;
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, falsebb);
    D.48387 = falsebb->cil_code;
    if (D.48387 != 0B) goto <D.48434>; else goto <D.48435>;
    <D.48434>:
    D.48390 = cfg->cil_offset_to_bb;
    D.48387 = falsebb->cil_code;
    D.48391 = (long int) D.48387;
    D.48392 = cfg->cil_start;
    D.48393 = (long int) D.48392;
    D.48394 = D.48391 - D.48393;
    D.48395 = (long unsigned int) D.48394;
    D.48396 = D.48395 * 8;
    D.48397 = D.48390 + D.48396;
    *D.48397 = falsebb;
    <D.48435>:
    D.48398 = cfg->real_offset;
    falsebb->real_offset = D.48398;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48439>; else goto <D.48436>;
    <D.48439>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48404 = D.48403 + 64985;
    if (D.48404 <= 9) goto <D.48437>; else goto <D.48440>;
    <D.48440>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48406 = D.48403 + 64878;
    if (D.48406 <= 9) goto <D.48437>; else goto <D.48441>;
    <D.48441>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48408 = D.48403 + 64888;
    if (D.48408 <= 9) goto <D.48437>; else goto <D.48436>;
    <D.48437>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48409 = D.48359->data.op[1].many_blocks;
    D.48410 = D.48409 + 8;
    D.48411 = *D.48410;
    if (D.48411 == 0B) goto <D.48442>; else goto <D.48436>;
    <D.48442>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48409 = D.48359->data.op[1].many_blocks;
    D.48410 = D.48409 + 8;
    *D.48410 = falsebb;
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, falsebb);
    goto <D.48438>;
    <D.48436>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 == 0B) goto <D.48443>; else goto <D.48445>;
    <D.48445>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    if (D.48403 != 442) goto <D.48446>; else goto <D.48444>;
    <D.48446>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    if (D.48403 != 759) goto <D.48447>; else goto <D.48444>;
    <D.48447>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48404 = D.48403 + 64985;
    if (D.48404 > 9) goto <D.48448>; else goto <D.48444>;
    <D.48448>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48406 = D.48403 + 64878;
    if (D.48406 > 9) goto <D.48449>; else goto <D.48444>;
    <D.48449>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48403 = D.48359->opcode;
    D.48408 = D.48403 + 64888;
    if (D.48408 > 9) goto <D.48443>; else goto <D.48444>;
    <D.48443>:
    D.48358 = cfg->cbb;
    mono_link_bblock (cfg, D.48358, falsebb);
    <D.48444>:
    <D.48438>:
    D.48358 = cfg->cbb;
    D.48358->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48450>;
    <D.48430>:
    D.48358 = cfg->cbb;
    D.48358->extended = 1;
    <D.48450>:
    <D.48420>:
  }
  save_cast_details (cfg, klass, obj_reg, 0, 0B);
  D.48451 = klass->flags;
  D.48452 = D.48451 & 32;
  if (D.48452 != 0) goto <D.48453>; else goto <D.48454>;
  <D.48453>:
  {
    struct MonoInst * inst;

    D.48347 = cfg->mempool;
    inst = mono_mempool_alloc (D.48347, 80);
    inst->data.op[1].const_val = 0;
    D.48455 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48455;
    inst->prev = 0B;
    D.48456 = inst->prev;
    inst->next = D.48456;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48457 = inst->sreg3;
    inst->sreg2 = D.48457;
    D.48458 = inst->sreg2;
    inst->sreg1 = D.48458;
    D.48354 = cfg->ip;
    inst->cil_code = D.48354;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    if (D.48359 != 0B) goto <D.48459>; else goto <D.48460>;
    <D.48459>:
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    D.48359->next = inst;
    D.48358 = cfg->cbb;
    D.48359 = D.48358->last_ins;
    inst->prev = D.48359;
    D.48358 = cfg->cbb;
    D.48358->last_ins = inst;
    goto <D.48461>;
    <D.48460>:
    D.48358 = cfg->cbb;
    D.48358 = cfg->cbb;
    D.48358->last_ins = inst;
    D.48359 = D.48358->last_ins;
    D.48358->code = D.48359;
    <D.48461>:
  }
  mini_emit_iface_cast (cfg, vtable_reg, klass, 0B, 0B);
  goto <D.48462>;
  <D.48454>:
  {
    int klass_reg;

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

      D.48347 = cfg->mempool;
      inst = mono_mempool_alloc (D.48347, 80);
      inst->data.op[1].const_val = 0;
      D.48464 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48464;
      inst->prev = 0B;
      D.48465 = inst->prev;
      inst->next = D.48465;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48466 = inst->sreg3;
      inst->sreg2 = D.48466;
      D.48467 = inst->sreg2;
      inst->sreg1 = D.48467;
      D.48354 = cfg->ip;
      inst->cil_code = D.48354;
      inst->dreg = vtable_reg;
      inst->sreg1 = obj_reg;
      inst->data.op[0].const_val = 0;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      if (D.48359 != 0B) goto <D.48468>; else goto <D.48469>;
      <D.48468>:
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      D.48359->next = inst;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      inst->prev = D.48359;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      goto <D.48470>;
      <D.48469>:
      D.48358 = cfg->cbb;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      D.48359 = D.48358->last_ins;
      D.48358->code = D.48359;
      <D.48470>:
    }
    D.48473 = klass->rank;
    if (D.48473 == 0) goto <D.48474>; else goto <D.48471>;
    <D.48474>:
    D.48427 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48475 = D.48427 & 274877906944;
    if (D.48475 == 0) goto <D.48476>; else goto <D.48471>;
    <D.48476>:
    D.48477 = cfg->opt;
    D.48478 = D.48477 & 512;
    if (D.48478 == 0) goto <D.48479>; else goto <D.48471>;
    <D.48479>:
    D.48451 = klass->flags;
    D.48480 = D.48451 & 256;
    if (D.48480 != 0) goto <D.48481>; else goto <D.48471>;
    <D.48481>:
    if (0 != 0) goto <D.48482>; else goto <D.48483>;
    <D.48482>:
    {
      struct MonoVTable * vt;

      D.48484 = cfg->domain;
      vt = mono_class_vtable (D.48484, klass);
      if (vt == 0B) goto <D.48485>; else goto <D.48486>;
      <D.48485>:
      mono_cfg_set_exception (cfg, 7);
      cfg->exception_ptr = klass;
      D.48363 = 0B;
      return D.48363;
      <D.48486>:
      {
        struct MonoInst * inst;

        D.48347 = cfg->mempool;
        inst = mono_mempool_alloc (D.48347, 80);
        inst->data.op[1].const_val = 0;
        D.48487 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48487;
        inst->prev = 0B;
        D.48488 = inst->prev;
        inst->next = D.48488;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48489 = inst->sreg3;
        inst->sreg2 = D.48489;
        D.48490 = inst->sreg2;
        inst->sreg1 = D.48490;
        D.48354 = cfg->ip;
        inst->cil_code = D.48354;
        inst->dreg = -1;
        inst->sreg1 = vtable_reg;
        vt.449 = (long int) vt;
        inst->data.op[1].const_val = vt.449;
        D.48358 = cfg->cbb;
        D.48359 = D.48358->last_ins;
        if (D.48359 != 0B) goto <D.48492>; else goto <D.48493>;
        <D.48492>:
        D.48358 = cfg->cbb;
        D.48359 = D.48358->last_ins;
        D.48359->next = inst;
        D.48358 = cfg->cbb;
        D.48359 = D.48358->last_ins;
        inst->prev = D.48359;
        D.48358 = cfg->cbb;
        D.48358->last_ins = inst;
        goto <D.48494>;
        <D.48493>:
        D.48358 = cfg->cbb;
        D.48358 = cfg->cbb;
        D.48358->last_ins = inst;
        D.48359 = D.48358->last_ins;
        D.48358->code = D.48359;
        <D.48494>:
      }
    }
    goto <D.48495>;
    <D.48483>:
    {
      struct MonoInst * inst;

      D.48347 = cfg->mempool;
      inst = mono_mempool_alloc (D.48347, 80);
      inst->data.op[1].const_val = 0;
      D.48496 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48496;
      inst->prev = 0B;
      D.48497 = inst->prev;
      inst->next = D.48497;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48498 = inst->sreg3;
      inst->sreg2 = D.48498;
      D.48499 = inst->sreg2;
      inst->sreg1 = D.48499;
      D.48354 = cfg->ip;
      inst->cil_code = D.48354;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      if (D.48359 != 0B) goto <D.48500>; else goto <D.48501>;
      <D.48500>:
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      D.48359->next = inst;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      inst->prev = D.48359;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      goto <D.48502>;
      <D.48501>:
      D.48358 = cfg->cbb;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      D.48359 = D.48358->last_ins;
      D.48358->code = D.48359;
      <D.48502>:
    }
    {
      struct MonoInst * inst;

      D.48347 = cfg->mempool;
      inst = mono_mempool_alloc (D.48347, 80);
      inst->data.op[1].const_val = 0;
      D.48503 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48503;
      inst->prev = 0B;
      D.48504 = inst->prev;
      inst->next = D.48504;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48505 = inst->sreg3;
      inst->sreg2 = D.48505;
      D.48506 = inst->sreg2;
      inst->sreg1 = D.48506;
      D.48354 = cfg->ip;
      inst->cil_code = D.48354;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      klass.450 = (long int) klass;
      inst->data.op[1].const_val = klass.450;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      if (D.48359 != 0B) goto <D.48508>; else goto <D.48509>;
      <D.48508>:
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      D.48359->next = inst;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      inst->prev = D.48359;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      goto <D.48510>;
      <D.48509>:
      D.48358 = cfg->cbb;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      D.48359 = D.48358->last_ins;
      D.48358->code = D.48359;
      <D.48510>:
    }
    <D.48495>:
    {
      struct MonoInst * inst;

      D.48347 = cfg->mempool;
      inst = mono_mempool_alloc (D.48347, 80);
      inst->data.op[1].const_val = 0;
      D.48511 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48511;
      inst->prev = 0B;
      D.48512 = inst->prev;
      inst->next = D.48512;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48513 = inst->sreg3;
      inst->sreg2 = D.48513;
      D.48514 = inst->sreg2;
      inst->sreg1 = D.48514;
      D.48354 = cfg->ip;
      inst->cil_code = D.48354;
      inst->data.op[1].p = "InvalidCastException";
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      if (D.48359 != 0B) goto <D.48515>; else goto <D.48516>;
      <D.48515>:
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      D.48359->next = inst;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      inst->prev = D.48359;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      goto <D.48517>;
      <D.48516>:
      D.48358 = cfg->cbb;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      D.48359 = D.48358->last_ins;
      D.48358->code = D.48359;
      <D.48517>:
    }
    goto <D.48472>;
    <D.48471>:
    {
      struct MonoInst * inst;

      D.48347 = cfg->mempool;
      inst = mono_mempool_alloc (D.48347, 80);
      inst->data.op[1].const_val = 0;
      D.48518 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48518;
      inst->prev = 0B;
      D.48519 = inst->prev;
      inst->next = D.48519;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48520 = inst->sreg3;
      inst->sreg2 = D.48520;
      D.48521 = inst->sreg2;
      inst->sreg1 = D.48521;
      D.48354 = cfg->ip;
      inst->cil_code = D.48354;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      if (D.48359 != 0B) goto <D.48522>; else goto <D.48523>;
      <D.48522>:
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      D.48359->next = inst;
      D.48358 = cfg->cbb;
      D.48359 = D.48358->last_ins;
      inst->prev = D.48359;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      goto <D.48524>;
      <D.48523>:
      D.48358 = cfg->cbb;
      D.48358 = cfg->cbb;
      D.48358->last_ins = inst;
      D.48359 = D.48358->last_ins;
      D.48358->code = D.48359;
      <D.48524>:
    }
    mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, klass_inst, is_null_bb);
    <D.48472>:
  }
  <D.48462>:
  D.48525 = is_null_bb->cil_code;
  if (D.48525 != 0B) goto <D.48526>; else goto <D.48527>;
  <D.48526>:
  D.48390 = cfg->cil_offset_to_bb;
  D.48525 = is_null_bb->cil_code;
  D.48528 = (long int) D.48525;
  D.48392 = cfg->cil_start;
  D.48393 = (long int) D.48392;
  D.48529 = D.48528 - D.48393;
  D.48530 = (long unsigned int) D.48529;
  D.48531 = D.48530 * 8;
  D.48532 = D.48390 + D.48531;
  *D.48532 = is_null_bb;
  <D.48527>:
  D.48398 = cfg->real_offset;
  is_null_bb->real_offset = D.48398;
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  if (D.48359 != 0B) goto <D.48536>; else goto <D.48533>;
  <D.48536>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48404 = D.48403 + 64985;
  if (D.48404 <= 9) goto <D.48534>; else goto <D.48537>;
  <D.48537>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48406 = D.48403 + 64878;
  if (D.48406 <= 9) goto <D.48534>; else goto <D.48538>;
  <D.48538>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48408 = D.48403 + 64888;
  if (D.48408 <= 9) goto <D.48534>; else goto <D.48533>;
  <D.48534>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48409 = D.48359->data.op[1].many_blocks;
  D.48410 = D.48409 + 8;
  D.48411 = *D.48410;
  if (D.48411 == 0B) goto <D.48539>; else goto <D.48533>;
  <D.48539>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48409 = D.48359->data.op[1].many_blocks;
  D.48410 = D.48409 + 8;
  *D.48410 = is_null_bb;
  D.48358 = cfg->cbb;
  mono_link_bblock (cfg, D.48358, is_null_bb);
  goto <D.48535>;
  <D.48533>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  if (D.48359 == 0B) goto <D.48540>; else goto <D.48542>;
  <D.48542>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  if (D.48403 != 442) goto <D.48543>; else goto <D.48541>;
  <D.48543>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  if (D.48403 != 759) goto <D.48544>; else goto <D.48541>;
  <D.48544>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48404 = D.48403 + 64985;
  if (D.48404 > 9) goto <D.48545>; else goto <D.48541>;
  <D.48545>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48406 = D.48403 + 64878;
  if (D.48406 > 9) goto <D.48546>; else goto <D.48541>;
  <D.48546>:
  D.48358 = cfg->cbb;
  D.48359 = D.48358->last_ins;
  D.48403 = D.48359->opcode;
  D.48408 = D.48403 + 64888;
  if (D.48408 > 9) goto <D.48540>; else goto <D.48541>;
  <D.48540>:
  D.48358 = cfg->cbb;
  mono_link_bblock (cfg, D.48358, is_null_bb);
  <D.48541>:
  <D.48535>:
  D.48358 = cfg->cbb;
  D.48358->next_bb = is_null_bb;
  cfg->cbb = is_null_bb;
  reset_cast_details (cfg);
  D.48363 = src;
  return D.48363;
}


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.48550;
  unsigned int D.48553;
  unsigned int D.48554;
  _Bool D.48555;
  long int D.48556;
  long int D.48557;
  struct MonoMemPool * D.48560;
  long int D.48561;
  struct MonoInst * D.48562;
  int D.48563;
  int D.48564;
  const unsigned char * D.48565;
  struct MonoBasicBlock * D.48566;
  struct MonoInst * D.48567;
  long int D.48571;
  struct MonoInst * D.48572;
  int D.48573;
  int D.48574;
  long int D.48575;
  long int D.48579;
  struct MonoInst * D.48580;
  int D.48581;
  int D.48582;
  long int D.48586;
  struct MonoInst * D.48587;
  int D.48588;
  int D.48589;
  struct MonoClass * D.48593;
  struct MonoClass * D.48594;
  unsigned int D.48597;
  long int D.48598;
  struct MonoInst * D.48599;
  int D.48600;
  int D.48601;
  struct MonoClass * D.48605;
  struct MonoClass * D.48606;
  unsigned int D.48614;
  unsigned int D.48615;
  unsigned char D.48621;
  unsigned int D.48626;
  long int D.48627;
  struct MonoInst * D.48628;
  int D.48629;
  int D.48630;
  long int D.48634;
  struct MonoInst * D.48635;
  int D.48636;
  int D.48637;
  long int D.48641;
  struct MonoInst * D.48642;
  int D.48643;
  int D.48644;
  unsigned int D.48649;
  unsigned int D.48650;
  unsigned int D.48651;
  short unsigned int D.48652;
  long int D.48655;
  struct MonoInst * D.48656;
  int D.48657;
  int D.48658;
  long int D.48662;
  struct MonoInst * D.48663;
  int D.48664;
  int D.48665;
  long int D.48666;
  long int D.48670;
  struct MonoInst * D.48671;
  int D.48672;
  int D.48673;
  long int D.48677;
  struct MonoInst * D.48678;
  int D.48679;
  int D.48680;
  long int D.48684;
  struct MonoInst * D.48685;
  int D.48686;
  int D.48687;
  int D.48688;
  int D.48689;
  int D.48690;
  long int D.48691;

  D.48550 = klass->rank;
  if (D.48550 != 0) goto <D.48551>; else goto <D.48552>;
  <D.48551>:
  {
    int rank_reg;
    int eclass_reg;

    D.48553 = alloc_preg (cfg);
    rank_reg = (int) D.48553;
    D.48554 = alloc_preg (cfg);
    eclass_reg = (int) D.48554;
    D.48555 = klass_inst != 0B;
    D.48556 = (long int) D.48555;
    D.48557 = __builtin_expect (D.48556, 0);
    if (D.48557 != 0) goto <D.48558>; else goto <D.48559>;
    <D.48558>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1685, "!klass_inst");
    <D.48559>:
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48561 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48561;
      inst->prev = 0B;
      D.48562 = inst->prev;
      inst->next = D.48562;
      inst->opcode = 390;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48563 = inst->sreg3;
      inst->sreg2 = D.48563;
      D.48564 = inst->sreg2;
      inst->sreg1 = D.48564;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = rank_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 26;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48568>; else goto <D.48569>;
      <D.48568>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48570>;
      <D.48569>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48570>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48571 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48571;
      inst->prev = 0B;
      D.48572 = inst->prev;
      inst->next = D.48572;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48573 = inst->sreg3;
      inst->sreg2 = D.48573;
      D.48574 = inst->sreg2;
      inst->sreg1 = D.48574;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = -1;
      inst->sreg1 = rank_reg;
      D.48550 = klass->rank;
      D.48575 = (long int) D.48550;
      inst->data.op[1].const_val = D.48575;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48576>; else goto <D.48577>;
      <D.48576>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48578>;
      <D.48577>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48578>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48579 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48579;
      inst->prev = 0B;
      D.48580 = inst->prev;
      inst->next = D.48580;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48581 = inst->sreg3;
      inst->sreg2 = D.48581;
      D.48582 = inst->sreg2;
      inst->sreg1 = D.48582;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->data.op[1].p = "InvalidCastException";
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48583>; else goto <D.48584>;
      <D.48583>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48585>;
      <D.48584>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48585>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48586 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48586;
      inst->prev = 0B;
      D.48587 = inst->prev;
      inst->next = D.48587;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48588 = inst->sreg3;
      inst->sreg2 = D.48588;
      D.48589 = inst->sreg2;
      inst->sreg1 = D.48589;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = eclass_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 8;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48590>; else goto <D.48591>;
      <D.48590>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48592>;
      <D.48591>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48592>:
    }
    D.48593 = klass->cast_class;
    D.48594 = mono_defaults.object_class;
    if (D.48593 == D.48594) goto <D.48595>; else goto <D.48596>;
    <D.48595>:
    {
      int parent_reg;

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

        D.48560 = cfg->mempool;
        inst = mono_mempool_alloc (D.48560, 80);
        inst->data.op[1].const_val = 0;
        D.48598 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48598;
        inst->prev = 0B;
        D.48599 = inst->prev;
        inst->next = D.48599;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48600 = inst->sreg3;
        inst->sreg2 = D.48600;
        D.48601 = inst->sreg2;
        inst->sreg1 = D.48601;
        D.48565 = cfg->ip;
        inst->cil_code = D.48565;
        inst->dreg = parent_reg;
        inst->sreg1 = eclass_reg;
        inst->data.op[0].const_val = 40;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        if (D.48567 != 0B) goto <D.48602>; else goto <D.48603>;
        <D.48602>:
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        D.48567->next = inst;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        inst->prev = D.48567;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        goto <D.48604>;
        <D.48603>:
        D.48566 = cfg->cbb;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        D.48567 = D.48566->last_ins;
        D.48566->code = D.48567;
        <D.48604>:
      }
      D.48605 = mono_defaults.enum_class;
      D.48606 = D.48605->parent;
      mini_emit_class_check_branch (cfg, parent_reg, D.48606, 556, object_is_null);
      D.48605 = mono_defaults.enum_class;
      mini_emit_class_check (cfg, eclass_reg, D.48605);
    }
    goto <D.48607>;
    <D.48596>:
    D.48593 = klass->cast_class;
    D.48605 = mono_defaults.enum_class;
    D.48606 = D.48605->parent;
    if (D.48593 == D.48606) goto <D.48608>; else goto <D.48609>;
    <D.48608>:
    D.48605 = mono_defaults.enum_class;
    D.48606 = D.48605->parent;
    mini_emit_class_check_branch (cfg, eclass_reg, D.48606, 551, object_is_null);
    D.48605 = mono_defaults.enum_class;
    mini_emit_class_check (cfg, eclass_reg, D.48605);
    goto <D.48610>;
    <D.48609>:
    D.48593 = klass->cast_class;
    D.48605 = mono_defaults.enum_class;
    if (D.48593 == D.48605) goto <D.48611>; else goto <D.48612>;
    <D.48611>:
    D.48605 = mono_defaults.enum_class;
    mini_emit_class_check (cfg, eclass_reg, D.48605);
    goto <D.48613>;
    <D.48612>:
    D.48593 = klass->cast_class;
    D.48614 = D.48593->flags;
    D.48615 = D.48614 & 32;
    if (D.48615 != 0) goto <D.48616>; else goto <D.48617>;
    <D.48616>:
    D.48593 = klass->cast_class;
    mini_emit_iface_class_cast (cfg, eclass_reg, D.48593, 0B, 0B);
    goto <D.48618>;
    <D.48617>:
    D.48593 = klass->cast_class;
    mini_emit_castclass (cfg, -1, eclass_reg, D.48593, object_is_null);
    <D.48618>:
    <D.48613>:
    <D.48610>:
    <D.48607>:
    D.48550 = klass->rank;
    if (D.48550 == 1) goto <D.48619>; else goto <D.48620>;
    <D.48619>:
    D.48621 = klass->byval_arg.type;
    if (D.48621 == 29) goto <D.48622>; else goto <D.48623>;
    <D.48622>:
    if (obj_reg != -1) goto <D.48624>; else goto <D.48625>;
    <D.48624>:
    {
      int bounds_reg;

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

        D.48560 = cfg->mempool;
        inst = mono_mempool_alloc (D.48560, 80);
        inst->data.op[1].const_val = 0;
        D.48627 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48627;
        inst->prev = 0B;
        D.48628 = inst->prev;
        inst->next = D.48628;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48629 = inst->sreg3;
        inst->sreg2 = D.48629;
        D.48630 = inst->sreg2;
        inst->sreg1 = D.48630;
        D.48565 = cfg->ip;
        inst->cil_code = D.48565;
        inst->dreg = bounds_reg;
        inst->sreg1 = obj_reg;
        inst->data.op[0].const_val = 16;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        if (D.48567 != 0B) goto <D.48631>; else goto <D.48632>;
        <D.48631>:
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        D.48567->next = inst;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        inst->prev = D.48567;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        goto <D.48633>;
        <D.48632>:
        D.48566 = cfg->cbb;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        D.48567 = D.48566->last_ins;
        D.48566->code = D.48567;
        <D.48633>:
      }
      {
        struct MonoInst * inst;

        D.48560 = cfg->mempool;
        inst = mono_mempool_alloc (D.48560, 80);
        inst->data.op[1].const_val = 0;
        D.48634 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48634;
        inst->prev = 0B;
        D.48635 = inst->prev;
        inst->next = D.48635;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48636 = inst->sreg3;
        inst->sreg2 = D.48636;
        D.48637 = inst->sreg2;
        inst->sreg1 = D.48637;
        D.48565 = cfg->ip;
        inst->cil_code = D.48565;
        inst->dreg = -1;
        inst->sreg1 = bounds_reg;
        inst->data.op[1].const_val = 0;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        if (D.48567 != 0B) goto <D.48638>; else goto <D.48639>;
        <D.48638>:
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        D.48567->next = inst;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        inst->prev = D.48567;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        goto <D.48640>;
        <D.48639>:
        D.48566 = cfg->cbb;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        D.48567 = D.48566->last_ins;
        D.48566->code = D.48567;
        <D.48640>:
      }
      {
        struct MonoInst * inst;

        D.48560 = cfg->mempool;
        inst = mono_mempool_alloc (D.48560, 80);
        inst->data.op[1].const_val = 0;
        D.48641 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.48641;
        inst->prev = 0B;
        D.48642 = inst->prev;
        inst->next = D.48642;
        inst->opcode = 456;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.48643 = inst->sreg3;
        inst->sreg2 = D.48643;
        D.48644 = inst->sreg2;
        inst->sreg1 = D.48644;
        D.48565 = cfg->ip;
        inst->cil_code = D.48565;
        inst->data.op[1].p = "InvalidCastException";
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        if (D.48567 != 0B) goto <D.48645>; else goto <D.48646>;
        <D.48645>:
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        D.48567->next = inst;
        D.48566 = cfg->cbb;
        D.48567 = D.48566->last_ins;
        inst->prev = D.48567;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        goto <D.48647>;
        <D.48646>:
        D.48566 = cfg->cbb;
        D.48566 = cfg->cbb;
        D.48566->last_ins = inst;
        D.48567 = D.48566->last_ins;
        D.48566->code = D.48567;
        <D.48647>:
      }
    }
    <D.48625>:
    <D.48623>:
    <D.48620>:
  }
  goto <D.48648>;
  <D.48552>:
  {
    int idepth_reg;
    int stypes_reg;
    int stype;

    D.48649 = alloc_preg (cfg);
    idepth_reg = (int) D.48649;
    D.48650 = alloc_preg (cfg);
    stypes_reg = (int) D.48650;
    D.48651 = alloc_preg (cfg);
    stype = (int) D.48651;
    mono_class_setup_supertypes (klass);
    D.48652 = klass->idepth;
    if (D.48652 > 6) goto <D.48653>; else goto <D.48654>;
    <D.48653>:
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48655 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48655;
      inst->prev = 0B;
      D.48656 = inst->prev;
      inst->next = D.48656;
      inst->opcode = 392;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48657 = inst->sreg3;
      inst->sreg2 = D.48657;
      D.48658 = inst->sreg2;
      inst->sreg1 = D.48658;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = idepth_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 24;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48659>; else goto <D.48660>;
      <D.48659>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48661>;
      <D.48660>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48661>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48662 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48662;
      inst->prev = 0B;
      D.48663 = inst->prev;
      inst->next = D.48663;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48664 = inst->sreg3;
      inst->sreg2 = D.48664;
      D.48665 = inst->sreg2;
      inst->sreg1 = D.48665;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = -1;
      inst->sreg1 = idepth_reg;
      D.48652 = klass->idepth;
      D.48666 = (long int) D.48652;
      inst->data.op[1].const_val = D.48666;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48667>; else goto <D.48668>;
      <D.48667>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48669>;
      <D.48668>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48669>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48670 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48670;
      inst->prev = 0B;
      D.48671 = inst->prev;
      inst->next = D.48671;
      inst->opcode = 460;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48672 = inst->sreg3;
      inst->sreg2 = D.48672;
      D.48673 = inst->sreg2;
      inst->sreg1 = D.48673;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->data.op[1].p = "InvalidCastException";
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48674>; else goto <D.48675>;
      <D.48674>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48676>;
      <D.48675>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48676>:
    }
    <D.48654>:
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48677 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48677;
      inst->prev = 0B;
      D.48678 = inst->prev;
      inst->next = D.48678;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48679 = inst->sreg3;
      inst->sreg2 = D.48679;
      D.48680 = inst->sreg2;
      inst->sreg1 = D.48680;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = stypes_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 16;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48681>; else goto <D.48682>;
      <D.48681>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48683>;
      <D.48682>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48683>:
    }
    {
      struct MonoInst * inst;

      D.48560 = cfg->mempool;
      inst = mono_mempool_alloc (D.48560, 80);
      inst->data.op[1].const_val = 0;
      D.48684 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48684;
      inst->prev = 0B;
      D.48685 = inst->prev;
      inst->next = D.48685;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48686 = inst->sreg3;
      inst->sreg2 = D.48686;
      D.48687 = inst->sreg2;
      inst->sreg1 = D.48687;
      D.48565 = cfg->ip;
      inst->cil_code = D.48565;
      inst->dreg = stype;
      inst->sreg1 = stypes_reg;
      D.48652 = klass->idepth;
      D.48688 = (int) D.48652;
      D.48689 = D.48688 + -1;
      D.48690 = D.48689 * 8;
      D.48691 = (long int) D.48690;
      inst->data.op[0].const_val = D.48691;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      if (D.48567 != 0B) goto <D.48692>; else goto <D.48693>;
      <D.48692>:
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      D.48567->next = inst;
      D.48566 = cfg->cbb;
      D.48567 = D.48566->last_ins;
      inst->prev = D.48567;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      goto <D.48694>;
      <D.48693>:
      D.48566 = cfg->cbb;
      D.48566 = cfg->cbb;
      D.48566->last_ins = inst;
      D.48567 = D.48566->last_ins;
      D.48566->code = D.48567;
      <D.48694>:
    }
    mini_emit_class_check_inst (cfg, stype, klass, klass_inst);
  }
  <D.48648>:
}


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.48697;
  long int D.48698;
  struct MonoInst * D.48699;
  int D.48700;
  int D.48701;
  const unsigned char * D.48702;
  int D.48703;
  struct MonoBasicBlock * D.48704;
  struct MonoInst * D.48705;
  long unsigned int D.48710;
  long unsigned int D.48711;
  unsigned int D.48714;
  long int D.48715;
  struct MonoInst * D.48716;
  guint16 iftmp.451;
  int D.48721;
  int D.48722;
  long int D.48725;
  struct MonoInst * D.48726;
  int D.48727;
  int D.48728;
  int D.48729;
  unsigned int D.48731;
  int D.48732;
  long int D.48736;
  struct MonoInst * D.48737;
  int D.48738;
  int D.48739;
  long int D.48744;
  struct MonoInst * D.48745;
  int D.48746;
  int D.48747;
  long int klass.452;
  long int D.48752;
  struct MonoInst * D.48753;
  int D.48754;
  int D.48755;

  if (klass_inst != 0B) goto <D.48695>; else goto <D.48696>;
  <D.48695>:
  {
    struct MonoInst * inst;

    D.48697 = cfg->mempool;
    inst = mono_mempool_alloc (D.48697, 80);
    inst->data.op[1].const_val = 0;
    D.48698 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48698;
    inst->prev = 0B;
    D.48699 = inst->prev;
    inst->next = D.48699;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48700 = inst->sreg3;
    inst->sreg2 = D.48700;
    D.48701 = inst->sreg2;
    inst->sreg1 = D.48701;
    D.48702 = cfg->ip;
    inst->cil_code = D.48702;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    D.48703 = klass_inst->dreg;
    inst->sreg2 = D.48703;
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    if (D.48705 != 0B) goto <D.48706>; else goto <D.48707>;
    <D.48706>:
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    D.48705->next = inst;
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    inst->prev = D.48705;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    goto <D.48708>;
    <D.48707>:
    D.48704 = cfg->cbb;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    D.48705 = D.48704->last_ins;
    D.48704->code = D.48705;
    <D.48708>:
  }
  goto <D.48709>;
  <D.48696>:
  D.48710 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.48711 = D.48710 & 274877906944;
  if (D.48711 != 0) goto <D.48712>; else goto <D.48713>;
  <D.48712>:
  {
    int const_reg;

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

      D.48697 = cfg->mempool;
      inst = mono_mempool_alloc (D.48697, 80);
      inst->data.op[1].const_val = 0;
      D.48715 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48715;
      inst->prev = 0B;
      D.48716 = inst->prev;
      inst->next = D.48716;
      D.48710 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.48711 = D.48710 & 274877906944;
      if (D.48711 != 0) goto <D.48718>; else goto <D.48719>;
      <D.48718>:
      iftmp.451 = 734;
      goto <D.48720>;
      <D.48719>:
      iftmp.451 = 363;
      <D.48720>:
      inst->opcode = iftmp.451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48721 = inst->sreg3;
      inst->sreg2 = D.48721;
      D.48722 = inst->sreg2;
      inst->sreg1 = D.48722;
      D.48702 = cfg->ip;
      inst->cil_code = D.48702;
      D.48710 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.48711 = D.48710 & 274877906944;
      if (D.48711 != 0) goto <D.48723>; else goto <D.48724>;
      <D.48723>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.48697 = cfg->mempool;
        group = mono_mempool_alloc (D.48697, 80);
        group->data.op[1].const_val = 0;
        D.48725 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.48725;
        group->prev = 0B;
        D.48726 = group->prev;
        group->next = D.48726;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.48727 = group->sreg3;
        group->sreg2 = D.48727;
        D.48728 = group->sreg2;
        group->sreg1 = D.48728;
        D.48702 = cfg->ip;
        group->cil_code = D.48702;
        group->data.op[0].src = klass;
        group->data.op[1].src = 11B;
        D.48729 = got_loc->dreg;
        inst->sreg1 = D.48729;
        inst->data.op[1].p = group;
      }
      goto <D.48730>;
      <D.48724>:
      inst->data.op[0].p = klass;
      inst->data.op[1].src = 11B;
      <D.48730>:
      inst->type = 3;
      D.48731 = alloc_dreg (cfg, 3);
      D.48732 = (int) D.48731;
      inst->dreg = D.48732;
      inst->dreg = const_reg;
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      if (D.48705 != 0B) goto <D.48733>; else goto <D.48734>;
      <D.48733>:
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      D.48705->next = inst;
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      inst->prev = D.48705;
      D.48704 = cfg->cbb;
      D.48704->last_ins = inst;
      goto <D.48735>;
      <D.48734>:
      D.48704 = cfg->cbb;
      D.48704 = cfg->cbb;
      D.48704->last_ins = inst;
      D.48705 = D.48704->last_ins;
      D.48704->code = D.48705;
      <D.48735>:
    }
    {
      struct MonoInst * inst;

      D.48697 = cfg->mempool;
      inst = mono_mempool_alloc (D.48697, 80);
      inst->data.op[1].const_val = 0;
      D.48736 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48736;
      inst->prev = 0B;
      D.48737 = inst->prev;
      inst->next = D.48737;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48738 = inst->sreg3;
      inst->sreg2 = D.48738;
      D.48739 = inst->sreg2;
      inst->sreg1 = D.48739;
      D.48702 = cfg->ip;
      inst->cil_code = D.48702;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      inst->sreg2 = const_reg;
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      if (D.48705 != 0B) goto <D.48740>; else goto <D.48741>;
      <D.48740>:
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      D.48705->next = inst;
      D.48704 = cfg->cbb;
      D.48705 = D.48704->last_ins;
      inst->prev = D.48705;
      D.48704 = cfg->cbb;
      D.48704->last_ins = inst;
      goto <D.48742>;
      <D.48741>:
      D.48704 = cfg->cbb;
      D.48704 = cfg->cbb;
      D.48704->last_ins = inst;
      D.48705 = D.48704->last_ins;
      D.48704->code = D.48705;
      <D.48742>:
    }
  }
  goto <D.48743>;
  <D.48713>:
  {
    struct MonoInst * inst;

    D.48697 = cfg->mempool;
    inst = mono_mempool_alloc (D.48697, 80);
    inst->data.op[1].const_val = 0;
    D.48744 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48744;
    inst->prev = 0B;
    D.48745 = inst->prev;
    inst->next = D.48745;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48746 = inst->sreg3;
    inst->sreg2 = D.48746;
    D.48747 = inst->sreg2;
    inst->sreg1 = D.48747;
    D.48702 = cfg->ip;
    inst->cil_code = D.48702;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    klass.452 = (long int) klass;
    inst->data.op[1].const_val = klass.452;
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    if (D.48705 != 0B) goto <D.48749>; else goto <D.48750>;
    <D.48749>:
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    D.48705->next = inst;
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    inst->prev = D.48705;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    goto <D.48751>;
    <D.48750>:
    D.48704 = cfg->cbb;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    D.48705 = D.48704->last_ins;
    D.48704->code = D.48705;
    <D.48751>:
  }
  <D.48743>:
  <D.48709>:
  {
    struct MonoInst * inst;

    D.48697 = cfg->mempool;
    inst = mono_mempool_alloc (D.48697, 80);
    inst->data.op[1].const_val = 0;
    D.48752 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48752;
    inst->prev = 0B;
    D.48753 = inst->prev;
    inst->next = D.48753;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48754 = inst->sreg3;
    inst->sreg2 = D.48754;
    D.48755 = inst->sreg2;
    inst->sreg1 = D.48755;
    D.48702 = cfg->ip;
    inst->cil_code = D.48702;
    inst->data.op[1].p = "InvalidCastException";
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    if (D.48705 != 0B) goto <D.48756>; else goto <D.48757>;
    <D.48756>:
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    D.48705->next = inst;
    D.48704 = cfg->cbb;
    D.48705 = D.48704->last_ins;
    inst->prev = D.48705;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    goto <D.48758>;
    <D.48757>:
    D.48704 = cfg->cbb;
    D.48704 = cfg->cbb;
    D.48704->last_ins = inst;
    D.48705 = D.48704->last_ins;
    D.48704->code = D.48705;
    <D.48758>:
  }
}


handle_stack_args (struct MonoCompile * cfg, struct MonoInst * * sp, int count)
{
  unsigned int D.48761;
  int D.48764;
  short unsigned int D.48765;
  short unsigned int D.48768;
  struct MonoBasicBlock * * D.48769;
  long unsigned int D.48770;
  long unsigned int D.48771;
  struct MonoBasicBlock * * D.48772;
  unsigned int D.48773;
  unsigned int D.48774;
  struct MonoInst * * D.48777;
  short int D.48780;
  int D.48781;
  struct MonoMemPool * D.48784;
  long unsigned int D.48785;
  unsigned int D.48786;
  unsigned int D.48787;
  void * D.48788;
  struct MonoMethod * D.48789;
  struct MonoInst * * D.48792;
  struct MonoInst * * D.48793;
  struct MonoInst * * D.48794;
  struct MonoInst * D.48795;
  struct MonoType * D.48796;
  struct MonoInst * D.48797;
  struct MonoInst * D.48799;
  short unsigned int D.48802;
  long int D.48807;
  struct MonoInst * D.48808;
  int D.48809;
  int D.48810;
  const unsigned char * D.48811;
  struct MonoInst * * D.48812;
  struct MonoInst * * D.48813;
  struct MonoInst * D.48814;
  long int D.48815;
  long unsigned int D.48816;
  long unsigned int D.48817;
  struct MonoInst * * D.48818;
  struct MonoInst * D.48819;
  struct MonoType * D.48820;
  unsigned int D.48821;
  short unsigned int D.48822;
  struct MonoClass * D.48823;
  int D.48824;
  int D.48825;
  short unsigned int D.48826;
  struct MonoClass * D.48829;
  struct MonoBasicBlock * D.48830;
  struct MonoInst * D.48831;
  const unsigned char * D.48835;
  int D.48838;
  long unsigned int D.48839;
  long unsigned int D.48840;
  struct MonoBasicBlock * * D.48841;
  struct MonoInst * * D.48846;
  struct MonoInst * D.48847;
  long int D.48848;
  long unsigned int D.48849;
  long unsigned int D.48850;
  struct MonoInst * * D.48851;
  struct MonoInst * D.48852;
  struct MonoType * D.48853;
  unsigned int D.48854;
  short unsigned int D.48855;
  struct MonoClass * D.48856;
  int D.48857;
  struct MonoClass * D.48860;
  int D.48866;
  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.48759>; else goto <D.48760>;
  <D.48759>:
  return;
  <D.48760>:
  D.48761 = cfg->verbose_level;
  if (D.48761 > 3) goto <D.48762>; else goto <D.48763>;
  <D.48762>:
  D.48764 = bb->block_num;
  printf ("%d item(s) on exit from B%d\n", count, D.48764);
  <D.48763>:
  D.48765 = bb->out_scount;
  if (D.48765 == 0) goto <D.48766>; else goto <D.48767>;
  <D.48766>:
  D.48768 = (short unsigned int) count;
  bb->out_scount = D.48768;
  found = 0;
  i = 0;
  goto <D.25300>;
  <D.25299>:
  D.48769 = bb->out_bb;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48772 = D.48769 + D.48771;
  outb = *D.48772;
  D.48773 = outb->flags;
  D.48774 = D.48773 & 16;
  if (D.48774 != 0) goto <D.48775>; else goto <D.48776>;
  <D.48775>:
  // predicted unlikely by continue predictor.
  goto <D.25297>;
  <D.48776>:
  D.48777 = outb->in_stack;
  if (D.48777 != 0B) goto <D.48778>; else goto <D.48779>;
  <D.48778>:
  found = 1;
  D.48777 = outb->in_stack;
  bb->out_stack = D.48777;
  goto <D.25298>;
  <D.48779>:
  <D.25297>:
  i = i + 1;
  <D.25300>:
  D.48780 = bb->out_count;
  D.48781 = (int) D.48780;
  if (D.48781 > i) goto <D.25299>; else goto <D.25298>;
  <D.25298>:
  if (found == 0) goto <D.48782>; else goto <D.48783>;
  <D.48782>:
  D.48784 = cfg->mempool;
  D.48785 = (long unsigned int) count;
  D.48786 = (unsigned int) D.48785;
  D.48787 = D.48786 * 8;
  D.48788 = mono_mempool_alloc (D.48784, D.48787);
  bb->out_stack = D.48788;
  i = 0;
  goto <D.25302>;
  <D.25301>:
  D.48789 = cfg->inlined_method;
  if (D.48789 != 0B) goto <D.48790>; else goto <D.48791>;
  <D.48790>:
  D.48792 = bb->out_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48793 = D.48792 + D.48771;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48796 = type_from_stack_type (D.48795);
  D.48797 = mono_compile_create_var (cfg, D.48796, 329);
  *D.48793 = D.48797;
  goto <D.48798>;
  <D.48791>:
  D.48792 = bb->out_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48793 = D.48792 + D.48771;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48799 = mono_compile_get_interface_var (cfg, i, D.48795);
  *D.48793 = D.48799;
  <D.48798>:
  i = i + 1;
  <D.25302>:
  if (i < count) goto <D.25301>; else goto <D.25303>;
  <D.25303>:
  <D.48783>:
  <D.48767>:
  i = 0;
  goto <D.25306>;
  <D.25305>:
  D.48769 = bb->out_bb;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48772 = D.48769 + D.48771;
  outb = *D.48772;
  D.48773 = outb->flags;
  D.48774 = D.48773 & 16;
  if (D.48774 != 0) goto <D.48800>; else goto <D.48801>;
  <D.48800>:
  // predicted unlikely by continue predictor.
  goto <D.25304>;
  <D.48801>:
  D.48802 = outb->in_scount;
  if (D.48802 != 0) goto <D.48803>; else goto <D.48804>;
  <D.48803>:
  D.48802 = outb->in_scount;
  D.48765 = bb->out_scount;
  if (D.48802 != D.48765) goto <D.48805>; else goto <D.48806>;
  <D.48805>:
  cfg->unverifiable = 1;
  return;
  <D.48806>:
  // predicted unlikely by continue predictor.
  goto <D.25304>;
  <D.48804>:
  D.48768 = (short unsigned int) count;
  outb->in_scount = D.48768;
  D.48792 = bb->out_stack;
  outb->in_stack = D.48792;
  <D.25304>:
  i = i + 1;
  <D.25306>:
  D.48780 = bb->out_count;
  D.48781 = (int) D.48780;
  if (D.48781 > i) goto <D.25305>; else goto <D.25307>;
  <D.25307>:
  locals = bb->out_stack;
  cfg->cbb = bb;
  i = 0;
  goto <D.25309>;
  <D.25308>:
  D.48784 = cfg->mempool;
  inst = mono_mempool_alloc (D.48784, 80);
  inst->data.op[1].const_val = 0;
  D.48807 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.48807;
  inst->prev = 0B;
  D.48808 = inst->prev;
  inst->next = D.48808;
  inst->opcode = 424;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.48809 = inst->sreg3;
  inst->sreg2 = D.48809;
  D.48810 = inst->sreg2;
  inst->sreg1 = D.48810;
  D.48811 = cfg->ip;
  inst->cil_code = D.48811;
  D.48812 = cfg->varinfo;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  D.48815 = D.48814->data.op[0].const_val;
  D.48816 = (long unsigned int) D.48815;
  D.48817 = D.48816 * 8;
  D.48818 = D.48812 + D.48817;
  D.48819 = *D.48818;
  D.48820 = D.48819->data.op[1].vtype;
  D.48821 = mono_type_to_regmove (cfg, D.48820);
  D.48822 = (short unsigned int) D.48821;
  inst->opcode = D.48822;
  D.48812 = cfg->varinfo;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  D.48815 = D.48814->data.op[0].const_val;
  D.48816 = (long unsigned int) D.48815;
  D.48817 = D.48816 * 8;
  D.48818 = D.48812 + D.48817;
  D.48819 = *D.48818;
  D.48823 = D.48819->klass;
  inst->klass = D.48823;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48824 = D.48795->dreg;
  inst->sreg1 = D.48824;
  D.48812 = cfg->varinfo;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  D.48815 = D.48814->data.op[0].const_val;
  D.48816 = (long unsigned int) D.48815;
  D.48817 = D.48816 * 8;
  D.48818 = D.48812 + D.48817;
  D.48819 = *D.48818;
  D.48825 = D.48819->dreg;
  inst->dreg = D.48825;
  D.48826 = inst->opcode;
  if (D.48826 == 427) goto <D.48827>; else goto <D.48828>;
  <D.48827>:
  D.48812 = cfg->varinfo;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  D.48815 = D.48814->data.op[0].const_val;
  D.48816 = (long unsigned int) D.48815;
  D.48817 = D.48816 * 8;
  D.48818 = D.48812 + D.48817;
  D.48819 = *D.48818;
  D.48820 = D.48819->data.op[1].vtype;
  D.48829 = mono_class_from_mono_type (D.48820);
  inst->klass = D.48829;
  <D.48828>:
  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>:
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48835 = D.48795->cil_code;
  inst->cil_code = D.48835;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  *D.48794 = D.48814;
  D.48761 = cfg->verbose_level;
  if (D.48761 > 3) goto <D.48836>; else goto <D.48837>;
  <D.48836>:
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  D.48815 = D.48814->data.op[0].const_val;
  D.48838 = (int) D.48815;
  printf ("storing %d to temp %d\n", i, D.48838);
  <D.48837>:
  i = i + 1;
  <D.25309>:
  if (i < count) goto <D.25308>; else goto <D.25310>;
  <D.25310>:
  found = 1;
  bindex = 0;
  goto <D.25318>;
  <D.25317>:
  found = 0;
  goto <D.25311>;
  <D.25316>:
  D.48769 = bb->out_bb;
  D.48839 = (long unsigned int) bindex;
  D.48840 = D.48839 * 8;
  D.48841 = D.48769 + D.48840;
  outb = *D.48841;
  D.48773 = outb->flags;
  D.48774 = D.48773 & 16;
  if (D.48774 != 0) goto <D.48842>; else goto <D.48843>;
  <D.48842>:
  bindex = bindex + 1;
  // predicted unlikely by continue predictor.
  goto <D.25311>;
  <D.48843>:
  D.48777 = outb->in_stack;
  if (D.48777 != locals) goto <D.48844>; else goto <D.48845>;
  <D.48844>:
  i = 0;
  goto <D.25313>;
  <D.25312>:
  D.48784 = cfg->mempool;
  inst = mono_mempool_alloc (D.48784, 80);
  inst->data.op[1].const_val = 0;
  D.48807 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.48807;
  inst->prev = 0B;
  D.48808 = inst->prev;
  inst->next = D.48808;
  inst->opcode = 424;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.48809 = inst->sreg3;
  inst->sreg2 = D.48809;
  D.48810 = inst->sreg2;
  inst->sreg1 = D.48810;
  D.48811 = cfg->ip;
  inst->cil_code = D.48811;
  D.48812 = cfg->varinfo;
  D.48777 = outb->in_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48846 = D.48777 + D.48771;
  D.48847 = *D.48846;
  D.48848 = D.48847->data.op[0].const_val;
  D.48849 = (long unsigned int) D.48848;
  D.48850 = D.48849 * 8;
  D.48851 = D.48812 + D.48850;
  D.48852 = *D.48851;
  D.48853 = D.48852->data.op[1].vtype;
  D.48854 = mono_type_to_regmove (cfg, D.48853);
  D.48855 = (short unsigned int) D.48854;
  inst->opcode = D.48855;
  D.48812 = cfg->varinfo;
  D.48777 = outb->in_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48846 = D.48777 + D.48771;
  D.48847 = *D.48846;
  D.48848 = D.48847->data.op[0].const_val;
  D.48849 = (long unsigned int) D.48848;
  D.48850 = D.48849 * 8;
  D.48851 = D.48812 + D.48850;
  D.48852 = *D.48851;
  D.48856 = D.48852->klass;
  inst->klass = D.48856;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48824 = D.48795->dreg;
  inst->sreg1 = D.48824;
  D.48812 = cfg->varinfo;
  D.48777 = outb->in_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48846 = D.48777 + D.48771;
  D.48847 = *D.48846;
  D.48848 = D.48847->data.op[0].const_val;
  D.48849 = (long unsigned int) D.48848;
  D.48850 = D.48849 * 8;
  D.48851 = D.48812 + D.48850;
  D.48852 = *D.48851;
  D.48857 = D.48852->dreg;
  inst->dreg = D.48857;
  D.48826 = inst->opcode;
  if (D.48826 == 427) goto <D.48858>; else goto <D.48859>;
  <D.48858>:
  D.48812 = cfg->varinfo;
  D.48777 = outb->in_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48846 = D.48777 + D.48771;
  D.48847 = *D.48846;
  D.48848 = D.48847->data.op[0].const_val;
  D.48849 = (long unsigned int) D.48848;
  D.48850 = D.48849 * 8;
  D.48851 = D.48812 + D.48850;
  D.48852 = *D.48851;
  D.48853 = D.48852->data.op[1].vtype;
  D.48860 = mono_class_from_mono_type (D.48853);
  inst->klass = D.48860;
  <D.48859>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.48861>; else goto <D.48862>;
  <D.48861>:
  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.48863>;
  <D.48862>:
  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.48863>:
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48795 = *D.48794;
  D.48835 = D.48795->cil_code;
  inst->cil_code = D.48835;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48794 = sp + D.48771;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48813 = locals + D.48771;
  D.48814 = *D.48813;
  *D.48794 = D.48814;
  D.48761 = cfg->verbose_level;
  if (D.48761 > 3) goto <D.48864>; else goto <D.48865>;
  <D.48864>:
  D.48777 = outb->in_stack;
  D.48770 = (long unsigned int) i;
  D.48771 = D.48770 * 8;
  D.48846 = D.48777 + D.48771;
  D.48847 = *D.48846;
  D.48848 = D.48847->data.op[0].const_val;
  D.48866 = (int) D.48848;
  printf ("storing %d to temp %d\n", i, D.48866);
  <D.48865>:
  i = i + 1;
  <D.25313>:
  if (i < count) goto <D.25312>; else goto <D.25314>;
  <D.25314>:
  locals = outb->in_stack;
  found = 1;
  goto <D.25315>;
  <D.48845>:
  bindex = bindex + 1;
  <D.25311>:
  D.48780 = bb->out_count;
  D.48781 = (int) D.48780;
  if (D.48781 > bindex) goto <D.25316>; else goto <D.25315>;
  <D.25315>:
  <D.25318>:
  if (found != 0) goto <D.25317>; else goto <D.25319>;
  <D.25319>:
}


mono_compile_get_interface_var (struct MonoCompile * cfg, int slot, struct MonoInst * ins)
{
  struct MonoMethodHeader * D.48868;
  <unnamed-unsigned:15> D.48869;
  int D.48870;
  struct MonoInst * D.48873;
  struct MonoType * D.48874;
  unsigned char D.48875;
  int D.48876;
  int D.48877;
  int D.48878;
  guint16 * D.48879;
  long unsigned int D.48880;
  long unsigned int D.48881;
  guint16 * D.48882;
  short unsigned int D.48883;
  struct MonoInst * * D.48886;
  long unsigned int D.48887;
  long unsigned int D.48888;
  struct MonoInst * * D.48889;
  struct MonoType * D.48890;
  long int D.48891;
  short unsigned int D.48892;
  struct MonoType * D.48893;
  struct MonoInst * res;
  int pos;
  int vnum;

  D.48868 = cfg->header;
  D.48869 = D.48868->max_stack;
  D.48870 = (int) D.48869;
  if (D.48870 <= slot) goto <D.48871>; else goto <D.48872>;
  <D.48871>:
  D.48874 = type_from_stack_type (ins);
  D.48873 = mono_compile_create_var (cfg, D.48874, 329);
  return D.48873;
  <D.48872>:
  D.48875 = ins->type;
  D.48876 = (int) D.48875;
  D.48877 = D.48876 + -1;
  D.48878 = slot * 8;
  pos = D.48877 + D.48878;
  D.48875 = ins->type;
  D.48876 = (int) D.48875;
  switch (D.48876) <default: <D.25277>, case 1: <D.25270>, case 2: <D.25271>, case 3: <D.25273>, case 4: <D.25272>, case 5: <D.25274>, case 6: <D.25275>>
  <D.25270>:
  <D.25271>:
  <D.25272>:
  <D.25273>:
  <D.25274>:
  <D.25275>:
  D.48879 = cfg->intvars;
  D.48880 = (long unsigned int) pos;
  D.48881 = D.48880 * 2;
  D.48882 = D.48879 + D.48881;
  D.48883 = *D.48882;
  vnum = (int) D.48883;
  if (vnum != 0) goto <D.48884>; else goto <D.48885>;
  <D.48884>:
  D.48886 = cfg->varinfo;
  D.48887 = (long unsigned int) vnum;
  D.48888 = D.48887 * 8;
  D.48889 = D.48886 + D.48888;
  D.48873 = *D.48889;
  return D.48873;
  <D.48885>:
  D.48890 = type_from_stack_type (ins);
  res = mono_compile_create_var (cfg, D.48890, 329);
  D.48879 = cfg->intvars;
  D.48880 = (long unsigned int) pos;
  D.48881 = D.48880 * 2;
  D.48882 = D.48879 + D.48881;
  D.48891 = res->data.op[0].const_val;
  D.48892 = (short unsigned int) D.48891;
  *D.48882 = D.48892;
  goto <D.25276>;
  <D.25277>:
  D.48893 = type_from_stack_type (ins);
  res = mono_compile_create_var (cfg, D.48893, 329);
  <D.25276>:
  D.48873 = res;
  return D.48873;
}


handle_box (struct MonoCompile * cfg, struct MonoInst * val, struct MonoClass * klass, int context_used, struct MonoBasicBlock * * out_cbb)
{
  struct MonoBasicBlock * D.48895;
  int D.48896;
  struct MonoMethod * D.48901;
  struct MonoInst * D.48902;
  struct MonoMethodSignature * D.48903;
  int pass_mrgctx.453;
  _Bool D.48905;
  long int D.48906;
  long int D.48907;
  int pass_vtable.454;
  struct MonoDomain * D.48913;
  struct MonoClass * D.48914;
  _Bool D.48915;
  long int D.48916;
  long int D.48917;
  struct MonoMemPool * D.48920;
  long int D.48921;
  struct MonoInst * D.48922;
  guint16 iftmp.455;
  long unsigned int D.48924;
  long unsigned int D.48925;
  int D.48929;
  int D.48930;
  const unsigned char * D.48931;
  long int D.48934;
  struct MonoInst * D.48935;
  int D.48936;
  int D.48937;
  struct MonoInst * iftmp.456;
  int D.48942;
  void * iftmp.457;
  unsigned int D.48948;
  int D.48949;
  struct MonoInst * D.48950;
  int D.48954;
  unsigned int D.48957;
  unsigned int D.48958;
  unsigned int D.48959;
  unsigned int D.48960;
  int D.48961;
  unsigned int D.48962;
  unsigned int D.48963;
  int D.48964;
  unsigned int D.48965;
  unsigned int D.48966;
  int D.48967;
  long int D.48968;
  struct MonoInst * D.48969;
  int D.48970;
  int D.48971;
  int D.48972;
  long int D.48976;
  struct MonoInst * D.48977;
  int D.48978;
  int D.48979;
  unsigned int D.48982;
  unsigned int D.48983;
  int D.48984;
  unsigned char * D.48988;
  struct MonoBasicBlock * * D.48991;
  long int D.48992;
  unsigned char * D.48993;
  long int D.48994;
  long int D.48995;
  long unsigned int D.48996;
  long unsigned int D.48997;
  struct MonoBasicBlock * * D.48998;
  unsigned int D.48999;
  short unsigned int D.49004;
  short unsigned int D.49005;
  short unsigned int D.49007;
  short unsigned int D.49009;
  struct MonoBasicBlock * * D.49010;
  struct MonoBasicBlock * * D.49011;
  struct MonoBasicBlock * D.49012;
  void * D.49022;
  struct MonoBasicBlock * * D.49023;
  struct MonoBasicBlock * * D.49024;
  long unsigned int D.49028;
  unsigned int D.49031;
  unsigned int D.49032;
  int D.49033;
  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.49064;
  unsigned int D.49065;
  int D.49066;
  unsigned char * D.49070;
  long int D.49073;
  long int D.49074;
  long unsigned int D.49075;
  long unsigned int D.49076;
  struct MonoBasicBlock * * D.49077;
  void * D.49093;
  struct MonoBasicBlock * * D.49094;
  struct MonoBasicBlock * * D.49095;
  unsigned int D.49101;
  unsigned int D.49102;
  int D.49103;
  long int D.49123;
  struct MonoInst * D.49124;
  struct MonoType * D.49125;
  unsigned int D.49126;
  short unsigned int D.49127;
  int D.49128;
  int D.49129;
  struct MonoInst * val.458;
  int D.49131;
  int D.49132;
  struct MonoClass * D.49133;
  long int D.49137;
  struct MonoInst * D.49138;
  int D.49139;
  int D.49140;
  long int D.49144;
  struct MonoInst * D.49145;
  int D.49146;
  int D.49147;
  unsigned int D.49150;
  unsigned int D.49151;
  int D.49152;
  unsigned char * D.49156;
  long int D.49159;
  long int D.49160;
  long unsigned int D.49161;
  long unsigned int D.49162;
  struct MonoBasicBlock * * D.49163;
  void * D.49179;
  struct MonoBasicBlock * * D.49180;
  struct MonoBasicBlock * * D.49181;
  unsigned int D.49187;
  unsigned int D.49188;
  int D.49189;
  unsigned char * D.49207;
  long int D.49210;
  long int D.49211;
  long unsigned int D.49212;
  long unsigned int D.49213;
  struct MonoBasicBlock * * D.49214;
  unsigned int D.49229;
  struct MonoInst * iftmp.459;
  unsigned int D.49231;
  unsigned int D.49232;
  struct MonoInst * * D.49235;
  long unsigned int D.49236;
  long unsigned int D.49237;
  struct MonoInst * * D.49238;
  long int D.49242;
  struct MonoInst * D.49243;
  int D.49244;
  int D.49245;
  unsigned char D.49246;
  unsigned char D.49247;
  struct MonoClass * D.49248;
  unsigned int D.49249;
  int D.49250;
  int D.49251;
  _Bool D.49252;
  long int D.49253;
  long int D.49254;
  struct MonoType * D.49257;
  int D.49258;
  struct MonoInst * iftmp.460;
  int D.49264;
  int D.49265;
  unsigned int D.49266;
  sizetype D.49269;
  sizetype D.49270;
  sizetype D.49271;
  struct MonoInst * * D.49272;
  struct MonoInst * iftmp.461;
  int D.49275;
  unsigned int D.49276;
  sizetype D.49279;
  sizetype D.49280;
  struct MonoInst * * D.49281;
  _Bool D.49283;
  long int D.49284;
  long int D.49285;
  _Bool D.49288;
  long int D.49289;
  long int D.49290;
  unsigned char D.49293;
  unsigned char D.49294;
  unsigned char D.49295;
  unsigned char D.49296;
  long int D.49300;
  struct MonoInst * D.49301;
  int D.49302;
  int D.49303;
  int D.49304;
  long int D.49308;
  struct MonoInst * D.49309;
  int D.49310;
  int D.49311;
  unsigned int D.49314;
  unsigned int D.49315;
  int D.49316;
  unsigned char * D.49320;
  long int D.49323;
  long int D.49324;
  long unsigned int D.49325;
  long unsigned int D.49326;
  struct MonoBasicBlock * * D.49327;
  void * D.49343;
  struct MonoBasicBlock * * D.49344;
  struct MonoBasicBlock * * D.49345;
  unsigned int D.49351;
  unsigned int D.49352;
  int D.49353;
  unsigned char * D.49371;
  long int D.49374;
  long int D.49375;
  long unsigned int D.49376;
  long unsigned int D.49377;
  struct MonoBasicBlock * * D.49378;
  struct MonoClass * D.49393;
  struct MonoType * D.49394;
  int D.49395;
  long int D.49399;
  struct MonoInst * D.49400;
  int D.49401;
  int D.49402;
  unsigned int D.49405;
  unsigned int D.49406;
  int D.49407;
  unsigned char * D.49411;
  long int D.49414;
  long int D.49415;
  long unsigned int D.49416;
  long unsigned int D.49417;
  struct MonoBasicBlock * * D.49418;
  void * D.49434;
  struct MonoBasicBlock * * D.49435;
  struct MonoBasicBlock * * D.49436;
  unsigned int D.49442;
  unsigned int D.49443;
  int D.49444;
  unsigned char * D.49462;
  long int D.49465;
  long int D.49466;
  long unsigned int D.49467;
  long unsigned int D.49468;
  struct MonoBasicBlock * * D.49469;
  unsigned int D.49486;
  short unsigned int D.49487;
  struct MonoClass * D.49488;
  struct MonoInst * alloc;
  struct MonoInst * ins;

  D.48895 = cfg->cbb;
  *out_cbb = D.48895;
  D.48896 = mono_class_is_nullable (klass);
  if (D.48896 != 0) goto <D.48897>; else goto <D.48898>;
  <D.48897>:
  {
    struct MonoMethod * method;

    method = mono_class_get_method_from_name (klass, "Box", 1);
    if (context_used != 0) goto <D.48899>; else goto <D.48900>;
    <D.48899>:
    {
      struct MonoInst * addr;
      struct MonoInst * rgctx;

      addr = emit_get_rgctx_method (cfg, context_used, method, 6);
      D.48901 = cfg->current_method;
      rgctx = emit_get_rgctx (cfg, D.48901, context_used);
      D.48903 = mono_method_signature (method);
      D.48902 = mono_emit_calli (cfg, D.48903, &val, addr, 0B, rgctx);
      return D.48902;
    }
    <D.48900>:
    {
      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.453 = pass_mrgctx;
          D.48905 = pass_mrgctx.453 != 0;
          D.48906 = (long int) D.48905;
          D.48907 = __builtin_expect (D.48906, 0);
          if (D.48907 != 0) goto <D.48908>; else goto <D.48909>;
          <D.48908>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3830, "!pass_mrgctx");
          <D.48909>:
          pass_vtable.454 = pass_vtable;
          if (pass_vtable.454 != 0) goto <D.48911>; else goto <D.48912>;
          <D.48911>:
          {
            struct MonoVTable * vtable;

            D.48913 = cfg->domain;
            D.48914 = method->klass;
            vtable = mono_class_vtable (D.48913, D.48914);
            D.48915 = vtable == 0B;
            D.48916 = (long int) D.48915;
            D.48917 = __builtin_expect (D.48916, 0);
            if (D.48917 != 0) goto <D.48918>; else goto <D.48919>;
            <D.48918>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3835, "vtable");
            <D.48919>:
            D.48920 = cfg->mempool;
            rgctx_arg = mono_mempool_alloc (D.48920, 80);
            rgctx_arg->data.op[1].const_val = 0;
            D.48921 = rgctx_arg->data.op[1].const_val;
            rgctx_arg->data.op[0].const_val = D.48921;
            rgctx_arg->prev = 0B;
            D.48922 = rgctx_arg->prev;
            rgctx_arg->next = D.48922;
            D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.48925 = D.48924 & 274877906944;
            if (D.48925 != 0) goto <D.48926>; else goto <D.48927>;
            <D.48926>:
            iftmp.455 = 734;
            goto <D.48928>;
            <D.48927>:
            iftmp.455 = 363;
            <D.48928>:
            rgctx_arg->opcode = iftmp.455;
            rgctx_arg->flags = 0;
            rgctx_arg->type = 0;
            rgctx_arg->dreg = -1;
            rgctx_arg->sreg3 = -1;
            D.48929 = rgctx_arg->sreg3;
            rgctx_arg->sreg2 = D.48929;
            D.48930 = rgctx_arg->sreg2;
            rgctx_arg->sreg1 = D.48930;
            D.48931 = cfg->ip;
            rgctx_arg->cil_code = D.48931;
            D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.48925 = D.48924 & 274877906944;
            if (D.48925 != 0) goto <D.48932>; else goto <D.48933>;
            <D.48932>:
            {
              struct MonoInst * group;
              struct MonoInst * got_loc;

              got_loc = mono_get_got_var (cfg);
              D.48920 = cfg->mempool;
              group = mono_mempool_alloc (D.48920, 80);
              group->data.op[1].const_val = 0;
              D.48934 = group->data.op[1].const_val;
              group->data.op[0].const_val = D.48934;
              group->prev = 0B;
              D.48935 = group->prev;
              group->next = D.48935;
              group->opcode = 733;
              group->flags = 0;
              group->type = 0;
              group->dreg = -1;
              group->sreg3 = -1;
              D.48936 = group->sreg3;
              group->sreg2 = D.48936;
              D.48937 = group->sreg2;
              group->sreg1 = D.48937;
              D.48931 = cfg->ip;
              group->cil_code = D.48931;
              D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.48925 = D.48924 & 274877906944;
              if (D.48925 != 0) goto <D.48939>; else goto <D.48940>;
              <D.48939>:
              iftmp.456 = vtable->klass;
              goto <D.48941>;
              <D.48940>:
              iftmp.456 = vtable;
              <D.48941>:
              group->data.op[0].src = iftmp.456;
              group->data.op[1].src = 14B;
              D.48942 = got_loc->dreg;
              rgctx_arg->sreg1 = D.48942;
              rgctx_arg->data.op[1].p = group;
            }
            goto <D.48943>;
            <D.48933>:
            D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.48925 = D.48924 & 274877906944;
            if (D.48925 != 0) goto <D.48945>; else goto <D.48946>;
            <D.48945>:
            iftmp.457 = vtable->klass;
            goto <D.48947>;
            <D.48946>:
            iftmp.457 = vtable;
            <D.48947>:
            rgctx_arg->data.op[0].p = iftmp.457;
            rgctx_arg->data.op[1].src = 14B;
            <D.48943>:
            rgctx_arg->type = 3;
            D.48948 = alloc_dreg (cfg, 3);
            D.48949 = (int) D.48948;
            rgctx_arg->dreg = D.48949;
            D.48895 = cfg->cbb;
            D.48950 = D.48895->last_ins;
            if (D.48950 != 0B) goto <D.48951>; else goto <D.48952>;
            <D.48951>:
            D.48895 = cfg->cbb;
            D.48950 = D.48895->last_ins;
            D.48950->next = rgctx_arg;
            D.48895 = cfg->cbb;
            D.48950 = D.48895->last_ins;
            rgctx_arg->prev = D.48950;
            D.48895 = cfg->cbb;
            D.48895->last_ins = rgctx_arg;
            goto <D.48953>;
            <D.48952>:
            D.48895 = cfg->cbb;
            D.48895 = cfg->cbb;
            D.48895->last_ins = rgctx_arg;
            D.48950 = D.48895->last_ins;
            D.48895->code = D.48950;
            <D.48953>:
          }
          <D.48912>:
          D.48902 = mono_emit_method_call_full (cfg, method, 0B, 0, &val, 0B, 0B, rgctx_arg);
          return D.48902;
        }
      finally
        {
          pass_vtable = {CLOBBER};
          pass_mrgctx = {CLOBBER};
        }
    }
  }
  <D.48898>:
  D.48954 = mini_is_gsharedvt_klass (cfg, klass);
  if (D.48954 != 0) goto <D.48955>; else goto <D.48956>;
  <D.48955>:
  {
    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.48957 = alloc_ireg (cfg);
    dreg = (int) D.48957;
    D.48920 = cfg->mempool;
    is_ref_bb = mono_mempool_alloc0 (D.48920, 296);
    D.48958 = cfg->num_bblocks;
    D.48959 = D.48958;
    D.48960 = D.48959 + 1;
    cfg->num_bblocks = D.48960;
    D.48961 = (int) D.48959;
    is_ref_bb->block_num = D.48961;
    D.48920 = cfg->mempool;
    is_nullable_bb = mono_mempool_alloc0 (D.48920, 296);
    D.48958 = cfg->num_bblocks;
    D.48962 = D.48958;
    D.48963 = D.48962 + 1;
    cfg->num_bblocks = D.48963;
    D.48964 = (int) D.48962;
    is_nullable_bb->block_num = D.48964;
    D.48920 = cfg->mempool;
    end_bb = mono_mempool_alloc0 (D.48920, 296);
    D.48958 = cfg->num_bblocks;
    D.48965 = D.48958;
    D.48966 = D.48965 + 1;
    cfg->num_bblocks = D.48966;
    D.48967 = (int) D.48965;
    end_bb->block_num = D.48967;
    is_ref = emit_get_gsharedvt_info_klass (cfg, klass, 19);
    {
      struct MonoInst * inst;

      D.48920 = cfg->mempool;
      inst = mono_mempool_alloc (D.48920, 80);
      inst->data.op[1].const_val = 0;
      D.48968 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.48968;
      inst->prev = 0B;
      D.48969 = inst->prev;
      inst->next = D.48969;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.48970 = inst->sreg3;
      inst->sreg2 = D.48970;
      D.48971 = inst->sreg2;
      inst->sreg1 = D.48971;
      D.48931 = cfg->ip;
      inst->cil_code = D.48931;
      inst->dreg = -1;
      D.48972 = is_ref->dreg;
      inst->sreg1 = D.48972;
      inst->data.op[1].const_val = 1;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.48973>; else goto <D.48974>;
      <D.48973>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = inst;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      inst->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      goto <D.48975>;
      <D.48974>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.48975>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.48920 = cfg->mempool;
      ins = mono_mempool_alloc (D.48920, 80);
      ins->data.op[1].const_val = 0;
      D.48976 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.48976;
      ins->prev = 0B;
      D.48977 = ins->prev;
      ins->next = D.48977;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.48978 = ins->sreg3;
      ins->sreg2 = D.48978;
      D.48979 = ins->sreg2;
      ins->sreg1 = D.48979;
      D.48931 = cfg->ip;
      ins->cil_code = D.48931;
      if (0 != 0) goto <D.48980>; else goto <D.48981>;
      <D.48980>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.48982 = D.48958;
      D.48983 = D.48982 + 1;
      cfg->num_bblocks = D.48983;
      D.48984 = (int) D.48982;
      falsebb->block_num = D.48984;
      ins->data.op[0].target_block = is_ref_bb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, is_ref_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.48985>; else goto <D.48986>;
      <D.48985>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.48987>;
      <D.48986>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.48987>:
      D.48988 = falsebb->cil_code;
      if (D.48988 != 0B) goto <D.48989>; else goto <D.48990>;
      <D.48989>:
      D.48991 = cfg->cil_offset_to_bb;
      D.48988 = falsebb->cil_code;
      D.48992 = (long int) D.48988;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.48995 = D.48992 - D.48994;
      D.48996 = (long unsigned int) D.48995;
      D.48997 = D.48996 * 8;
      D.48998 = D.48991 + D.48997;
      *D.48998 = falsebb;
      <D.48990>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49003>; else goto <D.49000>;
      <D.49003>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49001>; else goto <D.49006>;
      <D.49006>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49001>; else goto <D.49008>;
      <D.49008>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49001>; else goto <D.49000>;
      <D.49001>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49013>; else goto <D.49000>;
      <D.49013>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49002>;
      <D.49000>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49014>; else goto <D.49016>;
      <D.49016>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49017>; else goto <D.49015>;
      <D.49017>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49018>; else goto <D.49015>;
      <D.49018>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49019>; else goto <D.49015>;
      <D.49019>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49020>; else goto <D.49015>;
      <D.49020>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49014>; else goto <D.49015>;
      <D.49014>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49015>:
      <D.49002>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49021>;
      <D.48981>:
      D.48920 = cfg->mempool;
      D.49022 = mono_mempool_alloc (D.48920, 16);
      ins->data.op[1].many_blocks = D.49022;
      D.49023 = ins->data.op[1].many_blocks;
      *D.49023 = is_ref_bb;
      D.49023 = ins->data.op[1].many_blocks;
      D.49024 = D.49023 + 8;
      *D.49024 = 0B;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, is_ref_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49025>; else goto <D.49026>;
      <D.49025>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49027>;
      <D.49026>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49027>:
      D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.49028 = D.48924 & 34359738368;
      if (D.49028 == 0) goto <D.49029>; else goto <D.49030>;
      <D.49029>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49031 = D.48958;
      D.49032 = D.49031 + 1;
      cfg->num_bblocks = D.49032;
      D.49033 = (int) D.49031;
      falsebb->block_num = D.49033;
      D.49023 = ins->data.op[1].many_blocks;
      D.49024 = D.49023 + 8;
      *D.49024 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      D.48988 = falsebb->cil_code;
      if (D.48988 != 0B) goto <D.49034>; else goto <D.49035>;
      <D.49034>:
      D.48991 = cfg->cil_offset_to_bb;
      D.48988 = falsebb->cil_code;
      D.48992 = (long int) D.48988;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.48995 = D.48992 - D.48994;
      D.48996 = (long unsigned int) D.48995;
      D.48997 = D.48996 * 8;
      D.48998 = D.48991 + D.48997;
      *D.48998 = falsebb;
      <D.49035>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49039>; else goto <D.49036>;
      <D.49039>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49037>; else goto <D.49040>;
      <D.49040>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49037>; else goto <D.49041>;
      <D.49041>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49037>; else goto <D.49036>;
      <D.49037>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49042>; else goto <D.49036>;
      <D.49042>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49038>;
      <D.49036>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49043>; else goto <D.49045>;
      <D.49045>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49046>; else goto <D.49044>;
      <D.49046>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49047>; else goto <D.49044>;
      <D.49047>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49048>; else goto <D.49044>;
      <D.49048>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49049>; else goto <D.49044>;
      <D.49049>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49043>; else goto <D.49044>;
      <D.49043>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49044>:
      <D.49038>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49050>;
      <D.49030>:
      D.48895 = cfg->cbb;
      D.48895->extended = 1;
      <D.49050>:
      <D.49021>:
    }
    {
      struct MonoInst * inst;

      D.48920 = cfg->mempool;
      inst = mono_mempool_alloc (D.48920, 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 = 323;
      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.48931 = cfg->ip;
      inst->cil_code = D.48931;
      inst->dreg = -1;
      D.48972 = is_ref->dreg;
      inst->sreg1 = D.48972;
      inst->data.op[1].const_val = 2;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49055>; else goto <D.49056>;
      <D.49055>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = inst;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      inst->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      goto <D.49057>;
      <D.49056>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49057>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.48920 = cfg->mempool;
      ins = mono_mempool_alloc (D.48920, 80);
      ins->data.op[1].const_val = 0;
      D.49058 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.49058;
      ins->prev = 0B;
      D.49059 = ins->prev;
      ins->next = D.49059;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.49060 = ins->sreg3;
      ins->sreg2 = D.49060;
      D.49061 = ins->sreg2;
      ins->sreg1 = D.49061;
      D.48931 = cfg->ip;
      ins->cil_code = D.48931;
      if (0 != 0) goto <D.49062>; else goto <D.49063>;
      <D.49062>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49064 = D.48958;
      D.49065 = D.49064 + 1;
      cfg->num_bblocks = D.49065;
      D.49066 = (int) D.49064;
      falsebb->block_num = D.49066;
      ins->data.op[0].target_block = is_nullable_bb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, is_nullable_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49067>; else goto <D.49068>;
      <D.49067>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49069>;
      <D.49068>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49069>:
      D.49070 = falsebb->cil_code;
      if (D.49070 != 0B) goto <D.49071>; else goto <D.49072>;
      <D.49071>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49070 = falsebb->cil_code;
      D.49073 = (long int) D.49070;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49074 = D.49073 - D.48994;
      D.49075 = (long unsigned int) D.49074;
      D.49076 = D.49075 * 8;
      D.49077 = D.48991 + D.49076;
      *D.49077 = falsebb;
      <D.49072>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49081>; else goto <D.49078>;
      <D.49081>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49079>; else goto <D.49082>;
      <D.49082>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49079>; else goto <D.49083>;
      <D.49083>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49079>; else goto <D.49078>;
      <D.49079>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49084>; else goto <D.49078>;
      <D.49084>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49080>;
      <D.49078>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49085>; else goto <D.49087>;
      <D.49087>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49088>; else goto <D.49086>;
      <D.49088>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49089>; else goto <D.49086>;
      <D.49089>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49090>; else goto <D.49086>;
      <D.49090>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49091>; else goto <D.49086>;
      <D.49091>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49085>; else goto <D.49086>;
      <D.49085>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49086>:
      <D.49080>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49092>;
      <D.49063>:
      D.48920 = cfg->mempool;
      D.49093 = mono_mempool_alloc (D.48920, 16);
      ins->data.op[1].many_blocks = D.49093;
      D.49094 = ins->data.op[1].many_blocks;
      *D.49094 = is_nullable_bb;
      D.49094 = ins->data.op[1].many_blocks;
      D.49095 = D.49094 + 8;
      *D.49095 = 0B;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, is_nullable_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49096>; else goto <D.49097>;
      <D.49096>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49098>;
      <D.49097>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49098>:
      D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.49028 = D.48924 & 34359738368;
      if (D.49028 == 0) goto <D.49099>; else goto <D.49100>;
      <D.49099>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49101 = D.48958;
      D.49102 = D.49101 + 1;
      cfg->num_bblocks = D.49102;
      D.49103 = (int) D.49101;
      falsebb->block_num = D.49103;
      D.49094 = ins->data.op[1].many_blocks;
      D.49095 = D.49094 + 8;
      *D.49095 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      D.49070 = falsebb->cil_code;
      if (D.49070 != 0B) goto <D.49104>; else goto <D.49105>;
      <D.49104>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49070 = falsebb->cil_code;
      D.49073 = (long int) D.49070;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49074 = D.49073 - D.48994;
      D.49075 = (long unsigned int) D.49074;
      D.49076 = D.49075 * 8;
      D.49077 = D.48991 + D.49076;
      *D.49077 = falsebb;
      <D.49105>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49109>; else goto <D.49106>;
      <D.49109>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49107>; else goto <D.49110>;
      <D.49110>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49107>; else goto <D.49111>;
      <D.49111>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49107>; else goto <D.49106>;
      <D.49107>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49112>; else goto <D.49106>;
      <D.49112>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49108>;
      <D.49106>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49113>; else goto <D.49115>;
      <D.49115>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49116>; else goto <D.49114>;
      <D.49116>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49117>; else goto <D.49114>;
      <D.49117>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49118>; else goto <D.49114>;
      <D.49118>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49119>; else goto <D.49114>;
      <D.49119>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49113>; else goto <D.49114>;
      <D.49113>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49114>:
      <D.49108>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49120>;
      <D.49100>:
      D.48895 = cfg->cbb;
      D.48895->extended = 1;
      <D.49120>:
      <D.49092>:
    }
    alloc = handle_alloc (cfg, klass, 1, context_used);
    if (alloc == 0B) goto <D.49121>; else goto <D.49122>;
    <D.49121>:
    D.48902 = 0B;
    return D.48902;
    <D.49122>:
    D.48920 = cfg->mempool;
    ins = mono_mempool_alloc (D.48920, 80);
    ins->data.op[1].const_val = 0;
    D.49123 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.49123;
    ins->prev = 0B;
    D.49124 = ins->prev;
    ins->next = D.49124;
    D.49125 = &klass->byval_arg;
    D.49126 = mono_type_to_store_membase (cfg, D.49125);
    D.49127 = (short unsigned int) D.49126;
    ins->opcode = D.49127;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.49128 = ins->sreg3;
    ins->sreg2 = D.49128;
    D.49129 = ins->sreg2;
    ins->sreg1 = D.49129;
    D.48931 = cfg->ip;
    ins->cil_code = D.48931;
    val.458 = val;
    D.49131 = val.458->dreg;
    ins->sreg1 = D.49131;
    D.49132 = alloc->dreg;
    ins->dreg = D.49132;
    ins->data.op[0].const_val = 16;
    D.49125 = &klass->byval_arg;
    type_to_eval_stack_type (cfg, D.49125, ins);
    D.49125 = &klass->byval_arg;
    D.49133 = mono_class_from_mono_type (D.49125);
    ins->klass = D.49133;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49134>; else goto <D.49135>;
    <D.49134>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.48950->next = ins;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    ins->prev = D.48950;
    D.48895 = cfg->cbb;
    D.48895->last_ins = ins;
    goto <D.49136>;
    <D.49135>:
    D.48895 = cfg->cbb;
    D.48895 = cfg->cbb;
    D.48895->last_ins = ins;
    D.48950 = D.48895->last_ins;
    D.48895->code = D.48950;
    <D.49136>:
    ins->opcode = 387;
    D.48920 = cfg->mempool;
    res = mono_mempool_alloc (D.48920, 80);
    res->data.op[1].const_val = 0;
    D.49137 = res->data.op[1].const_val;
    res->data.op[0].const_val = D.49137;
    res->prev = 0B;
    D.49138 = res->prev;
    res->next = D.49138;
    res->opcode = 424;
    res->flags = 0;
    res->type = 0;
    res->dreg = -1;
    res->sreg3 = -1;
    D.49139 = res->sreg3;
    res->sreg2 = D.49139;
    D.49140 = res->sreg2;
    res->sreg1 = D.49140;
    D.48931 = cfg->ip;
    res->cil_code = D.48931;
    res->dreg = dreg;
    D.49132 = alloc->dreg;
    res->sreg1 = D.49132;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49141>; else goto <D.49142>;
    <D.49141>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.48950->next = res;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    res->prev = D.48950;
    D.48895 = cfg->cbb;
    D.48895->last_ins = res;
    goto <D.49143>;
    <D.49142>:
    D.48895 = cfg->cbb;
    D.48895 = cfg->cbb;
    D.48895->last_ins = res;
    D.48950 = D.48895->last_ins;
    D.48895->code = D.48950;
    <D.49143>:
    res->type = 6;
    res->klass = klass;
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.48920 = cfg->mempool;
      ins = mono_mempool_alloc (D.48920, 80);
      ins->data.op[1].const_val = 0;
      D.49144 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.49144;
      ins->prev = 0B;
      D.49145 = ins->prev;
      ins->next = D.49145;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.49146 = ins->sreg3;
      ins->sreg2 = D.49146;
      D.49147 = ins->sreg2;
      ins->sreg1 = D.49147;
      D.48931 = cfg->ip;
      ins->cil_code = D.48931;
      if (1 != 0) goto <D.49148>; else goto <D.49149>;
      <D.49148>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49150 = D.48958;
      D.49151 = D.49150 + 1;
      cfg->num_bblocks = D.49151;
      D.49152 = (int) D.49150;
      falsebb->block_num = D.49152;
      ins->data.op[0].target_block = end_bb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49153>; else goto <D.49154>;
      <D.49153>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49155>;
      <D.49154>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49155>:
      D.49156 = falsebb->cil_code;
      if (D.49156 != 0B) goto <D.49157>; else goto <D.49158>;
      <D.49157>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49156 = falsebb->cil_code;
      D.49159 = (long int) D.49156;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49160 = D.49159 - D.48994;
      D.49161 = (long unsigned int) D.49160;
      D.49162 = D.49161 * 8;
      D.49163 = D.48991 + D.49162;
      *D.49163 = falsebb;
      <D.49158>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49167>; else goto <D.49164>;
      <D.49167>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49165>; else goto <D.49168>;
      <D.49168>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49165>; else goto <D.49169>;
      <D.49169>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49165>; else goto <D.49164>;
      <D.49165>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49170>; else goto <D.49164>;
      <D.49170>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49166>;
      <D.49164>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49171>; else goto <D.49173>;
      <D.49173>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49174>; else goto <D.49172>;
      <D.49174>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49175>; else goto <D.49172>;
      <D.49175>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49176>; else goto <D.49172>;
      <D.49176>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49177>; else goto <D.49172>;
      <D.49177>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49171>; else goto <D.49172>;
      <D.49171>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49172>:
      <D.49166>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49178>;
      <D.49149>:
      D.48920 = cfg->mempool;
      D.49179 = mono_mempool_alloc (D.48920, 16);
      ins->data.op[1].many_blocks = D.49179;
      D.49180 = ins->data.op[1].many_blocks;
      *D.49180 = end_bb;
      D.49180 = ins->data.op[1].many_blocks;
      D.49181 = D.49180 + 8;
      *D.49181 = 0B;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49182>; else goto <D.49183>;
      <D.49182>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49184>;
      <D.49183>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49184>:
      D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.49028 = D.48924 & 34359738368;
      if (D.49028 == 0) goto <D.49185>; else goto <D.49186>;
      <D.49185>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49187 = D.48958;
      D.49188 = D.49187 + 1;
      cfg->num_bblocks = D.49188;
      D.49189 = (int) D.49187;
      falsebb->block_num = D.49189;
      D.49180 = ins->data.op[1].many_blocks;
      D.49181 = D.49180 + 8;
      *D.49181 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      D.49156 = falsebb->cil_code;
      if (D.49156 != 0B) goto <D.49190>; else goto <D.49191>;
      <D.49190>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49156 = falsebb->cil_code;
      D.49159 = (long int) D.49156;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49160 = D.49159 - D.48994;
      D.49161 = (long unsigned int) D.49160;
      D.49162 = D.49161 * 8;
      D.49163 = D.48991 + D.49162;
      *D.49163 = falsebb;
      <D.49191>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49195>; else goto <D.49192>;
      <D.49195>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49193>; else goto <D.49196>;
      <D.49196>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49193>; else goto <D.49197>;
      <D.49197>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49193>; else goto <D.49192>;
      <D.49193>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49198>; else goto <D.49192>;
      <D.49198>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49194>;
      <D.49192>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49199>; else goto <D.49201>;
      <D.49201>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49202>; else goto <D.49200>;
      <D.49202>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49203>; else goto <D.49200>;
      <D.49203>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49204>; else goto <D.49200>;
      <D.49204>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49205>; else goto <D.49200>;
      <D.49205>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49199>; else goto <D.49200>;
      <D.49199>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49200>:
      <D.49194>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49206>;
      <D.49186>:
      D.48895 = cfg->cbb;
      D.48895->extended = 1;
      <D.49206>:
      <D.49178>:
    }
    D.49207 = is_ref_bb->cil_code;
    if (D.49207 != 0B) goto <D.49208>; else goto <D.49209>;
    <D.49208>:
    D.48991 = cfg->cil_offset_to_bb;
    D.49207 = is_ref_bb->cil_code;
    D.49210 = (long int) D.49207;
    D.48993 = cfg->cil_start;
    D.48994 = (long int) D.48993;
    D.49211 = D.49210 - D.48994;
    D.49212 = (long unsigned int) D.49211;
    D.49213 = D.49212 * 8;
    D.49214 = D.48991 + D.49213;
    *D.49214 = is_ref_bb;
    <D.49209>:
    D.48999 = cfg->real_offset;
    is_ref_bb->real_offset = D.48999;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49218>; else goto <D.49215>;
    <D.49218>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 <= 9) goto <D.49216>; else goto <D.49219>;
    <D.49219>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 <= 9) goto <D.49216>; else goto <D.49220>;
    <D.49220>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 <= 9) goto <D.49216>; else goto <D.49215>;
    <D.49216>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    D.49012 = *D.49011;
    if (D.49012 == 0B) goto <D.49221>; else goto <D.49215>;
    <D.49221>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    *D.49011 = is_ref_bb;
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, is_ref_bb);
    goto <D.49217>;
    <D.49215>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 == 0B) goto <D.49222>; else goto <D.49224>;
    <D.49224>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 442) goto <D.49225>; else goto <D.49223>;
    <D.49225>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 759) goto <D.49226>; else goto <D.49223>;
    <D.49226>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 > 9) goto <D.49227>; else goto <D.49223>;
    <D.49227>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 > 9) goto <D.49228>; else goto <D.49223>;
    <D.49228>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 > 9) goto <D.49222>; else goto <D.49223>;
    <D.49222>:
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, is_ref_bb);
    <D.49223>:
    <D.49217>:
    D.48895 = cfg->cbb;
    D.48895->next_bb = is_ref_bb;
    cfg->cbb = is_ref_bb;
    D.49229 = alloc_ireg (cfg);
    addr_reg = (int) D.49229;
    val.458 = val;
    D.49131 = val.458->dreg;
    D.49231 = (unsigned int) D.49131;
    D.49232 = cfg->vreg_to_inst_len;
    if (D.49231 < D.49232) goto <D.49233>; else goto <D.49234>;
    <D.49233>:
    D.49235 = cfg->vreg_to_inst;
    val.458 = val;
    D.49131 = val.458->dreg;
    D.49236 = (long unsigned int) D.49131;
    D.49237 = D.49236 * 8;
    D.49238 = D.49235 + D.49237;
    iftmp.459 = *D.49238;
    goto <D.49239>;
    <D.49234>:
    iftmp.459 = 0B;
    <D.49239>:
    src_var = iftmp.459;
    if (src_var == 0B) goto <D.49240>; else goto <D.49241>;
    <D.49240>:
    D.49125 = &klass->byval_arg;
    val.458 = val;
    D.49131 = val.458->dreg;
    src_var = mono_compile_create_var_for_vreg (cfg, D.49125, 329, D.49131);
    <D.49241>:
    D.48920 = cfg->mempool;
    addr = mono_mempool_alloc (D.48920, 80);
    addr->data.op[1].const_val = 0;
    D.49242 = addr->data.op[1].const_val;
    addr->data.op[0].const_val = D.49242;
    addr->prev = 0B;
    D.49243 = addr->prev;
    addr->next = D.49243;
    addr->opcode = 314;
    addr->flags = 0;
    addr->type = 0;
    addr->dreg = -1;
    addr->sreg3 = -1;
    D.49244 = addr->sreg3;
    addr->sreg2 = D.49244;
    D.49245 = addr->sreg2;
    addr->sreg1 = D.49245;
    D.48931 = cfg->ip;
    addr->cil_code = D.48931;
    addr->data.op[0].p = src_var;
    D.49246 = src_var->flags;
    D.49247 = D.49246 | 16;
    src_var->flags = D.49247;
    addr->type = 5;
    D.49248 = src_var->klass;
    addr->klass = D.49248;
    D.49249 = alloc_dreg (cfg, 5);
    D.49250 = (int) D.49249;
    addr->dreg = D.49250;
    cfg->has_indirection = 1;
    D.49251 = cfg->gsharedvt;
    D.49252 = D.49251 != 0;
    D.49253 = (long int) D.49252;
    D.49254 = __builtin_expect (D.49253, 0);
    if (D.49254 != 0) goto <D.49255>; else goto <D.49256>;
    <D.49255>:
    D.49257 = src_var->data.op[1].vtype;
    D.49258 = mini_is_gsharedvt_variable_type (cfg, D.49257);
    if (D.49258 != 0) goto <D.49259>; else goto <D.49260>;
    <D.49259>:
    handle_gsharedvt_ldaddr (cfg);
    <D.49260>:
    <D.49256>:
    if (0 != 0) goto <D.49261>; else goto <D.49262>;
    <D.49261>:
    {
      struct MonoInst * var1;
      struct MonoInst * var2;

      D.49264 = src_var->dreg;
      D.49265 = D.49264 + 1;
      D.49266 = (unsigned int) D.49265;
      D.49232 = cfg->vreg_to_inst_len;
      if (D.49266 < D.49232) goto <D.49267>; else goto <D.49268>;
      <D.49267>:
      D.49235 = cfg->vreg_to_inst;
      D.49264 = src_var->dreg;
      D.49269 = (sizetype) D.49264;
      D.49270 = D.49269 + 1;
      D.49271 = D.49270 * 8;
      D.49272 = D.49235 + D.49271;
      iftmp.460 = *D.49272;
      goto <D.49273>;
      <D.49268>:
      iftmp.460 = 0B;
      <D.49273>:
      var1 = iftmp.460;
      D.49264 = src_var->dreg;
      D.49275 = D.49264 + 2;
      D.49276 = (unsigned int) D.49275;
      D.49232 = cfg->vreg_to_inst_len;
      if (D.49276 < D.49232) goto <D.49277>; else goto <D.49278>;
      <D.49277>:
      D.49235 = cfg->vreg_to_inst;
      D.49264 = src_var->dreg;
      D.49269 = (sizetype) D.49264;
      D.49279 = D.49269 + 2;
      D.49280 = D.49279 * 8;
      D.49281 = D.49235 + D.49280;
      iftmp.461 = *D.49281;
      goto <D.49282>;
      <D.49278>:
      iftmp.461 = 0B;
      <D.49282>:
      var2 = iftmp.461;
      D.49283 = var1 == 0B;
      D.49284 = (long int) D.49283;
      D.49285 = __builtin_expect (D.49284, 0);
      if (D.49285 != 0) goto <D.49286>; else goto <D.49287>;
      <D.49286>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3880, "var1");
      <D.49287>:
      D.49288 = var2 == 0B;
      D.49289 = (long int) D.49288;
      D.49290 = __builtin_expect (D.49289, 0);
      if (D.49290 != 0) goto <D.49291>; else goto <D.49292>;
      <D.49291>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3880, "var2");
      <D.49292>:
      D.49293 = var1->flags;
      D.49294 = D.49293 | 16;
      var1->flags = D.49294;
      D.49295 = var2->flags;
      D.49296 = D.49295 | 16;
      var2->flags = D.49296;
    }
    <D.49262>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49297>; else goto <D.49298>;
    <D.49297>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.48950->next = addr;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    addr->prev = D.48950;
    D.48895 = cfg->cbb;
    D.48895->last_ins = addr;
    goto <D.49299>;
    <D.49298>:
    D.48895 = cfg->cbb;
    D.48895 = cfg->cbb;
    D.48895->last_ins = addr;
    D.48950 = D.48895->last_ins;
    D.48895->code = D.48950;
    <D.49299>:
    {
      struct MonoInst * inst;

      D.48920 = cfg->mempool;
      inst = mono_mempool_alloc (D.48920, 80);
      inst->data.op[1].const_val = 0;
      D.49300 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49300;
      inst->prev = 0B;
      D.49301 = inst->prev;
      inst->next = D.49301;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49302 = inst->sreg3;
      inst->sreg2 = D.49302;
      D.49303 = inst->sreg2;
      inst->sreg1 = D.49303;
      D.48931 = cfg->ip;
      inst->cil_code = D.48931;
      inst->dreg = dreg;
      D.49304 = addr->dreg;
      inst->sreg1 = D.49304;
      inst->data.op[0].const_val = 0;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49305>; else goto <D.49306>;
      <D.49305>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = inst;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      inst->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      goto <D.49307>;
      <D.49306>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = inst;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49307>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.48920 = cfg->mempool;
      ins = mono_mempool_alloc (D.48920, 80);
      ins->data.op[1].const_val = 0;
      D.49308 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.49308;
      ins->prev = 0B;
      D.49309 = ins->prev;
      ins->next = D.49309;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.49310 = ins->sreg3;
      ins->sreg2 = D.49310;
      D.49311 = ins->sreg2;
      ins->sreg1 = D.49311;
      D.48931 = cfg->ip;
      ins->cil_code = D.48931;
      if (1 != 0) goto <D.49312>; else goto <D.49313>;
      <D.49312>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49314 = D.48958;
      D.49315 = D.49314 + 1;
      cfg->num_bblocks = D.49315;
      D.49316 = (int) D.49314;
      falsebb->block_num = D.49316;
      ins->data.op[0].target_block = end_bb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49317>; else goto <D.49318>;
      <D.49317>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49319>;
      <D.49318>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49319>:
      D.49320 = falsebb->cil_code;
      if (D.49320 != 0B) goto <D.49321>; else goto <D.49322>;
      <D.49321>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49320 = falsebb->cil_code;
      D.49323 = (long int) D.49320;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49324 = D.49323 - D.48994;
      D.49325 = (long unsigned int) D.49324;
      D.49326 = D.49325 * 8;
      D.49327 = D.48991 + D.49326;
      *D.49327 = falsebb;
      <D.49322>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49331>; else goto <D.49328>;
      <D.49331>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49329>; else goto <D.49332>;
      <D.49332>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49329>; else goto <D.49333>;
      <D.49333>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49329>; else goto <D.49328>;
      <D.49329>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49334>; else goto <D.49328>;
      <D.49334>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49330>;
      <D.49328>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49335>; else goto <D.49337>;
      <D.49337>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49338>; else goto <D.49336>;
      <D.49338>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49339>; else goto <D.49336>;
      <D.49339>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49340>; else goto <D.49336>;
      <D.49340>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49341>; else goto <D.49336>;
      <D.49341>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49335>; else goto <D.49336>;
      <D.49335>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49336>:
      <D.49330>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49342>;
      <D.49313>:
      D.48920 = cfg->mempool;
      D.49343 = mono_mempool_alloc (D.48920, 16);
      ins->data.op[1].many_blocks = D.49343;
      D.49344 = ins->data.op[1].many_blocks;
      *D.49344 = end_bb;
      D.49344 = ins->data.op[1].many_blocks;
      D.49345 = D.49344 + 8;
      *D.49345 = 0B;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49346>; else goto <D.49347>;
      <D.49346>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49348>;
      <D.49347>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49348>:
      D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.49028 = D.48924 & 34359738368;
      if (D.49028 == 0) goto <D.49349>; else goto <D.49350>;
      <D.49349>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49351 = D.48958;
      D.49352 = D.49351 + 1;
      cfg->num_bblocks = D.49352;
      D.49353 = (int) D.49351;
      falsebb->block_num = D.49353;
      D.49344 = ins->data.op[1].many_blocks;
      D.49345 = D.49344 + 8;
      *D.49345 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      D.49320 = falsebb->cil_code;
      if (D.49320 != 0B) goto <D.49354>; else goto <D.49355>;
      <D.49354>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49320 = falsebb->cil_code;
      D.49323 = (long int) D.49320;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49324 = D.49323 - D.48994;
      D.49325 = (long unsigned int) D.49324;
      D.49326 = D.49325 * 8;
      D.49327 = D.48991 + D.49326;
      *D.49327 = falsebb;
      <D.49355>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49359>; else goto <D.49356>;
      <D.49359>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49357>; else goto <D.49360>;
      <D.49360>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49357>; else goto <D.49361>;
      <D.49361>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49357>; else goto <D.49356>;
      <D.49357>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49362>; else goto <D.49356>;
      <D.49362>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49358>;
      <D.49356>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49363>; else goto <D.49365>;
      <D.49365>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49366>; else goto <D.49364>;
      <D.49366>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49367>; else goto <D.49364>;
      <D.49367>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49368>; else goto <D.49364>;
      <D.49368>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49369>; else goto <D.49364>;
      <D.49369>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49363>; else goto <D.49364>;
      <D.49363>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49364>:
      <D.49358>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49370>;
      <D.49350>:
      D.48895 = cfg->cbb;
      D.48895->extended = 1;
      <D.49370>:
      <D.49342>:
    }
    D.49371 = is_nullable_bb->cil_code;
    if (D.49371 != 0B) goto <D.49372>; else goto <D.49373>;
    <D.49372>:
    D.48991 = cfg->cil_offset_to_bb;
    D.49371 = is_nullable_bb->cil_code;
    D.49374 = (long int) D.49371;
    D.48993 = cfg->cil_start;
    D.48994 = (long int) D.48993;
    D.49375 = D.49374 - D.48994;
    D.49376 = (long unsigned int) D.49375;
    D.49377 = D.49376 * 8;
    D.49378 = D.48991 + D.49377;
    *D.49378 = is_nullable_bb;
    <D.49373>:
    D.48999 = cfg->real_offset;
    is_nullable_bb->real_offset = D.48999;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49382>; else goto <D.49379>;
    <D.49382>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 <= 9) goto <D.49380>; else goto <D.49383>;
    <D.49383>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 <= 9) goto <D.49380>; else goto <D.49384>;
    <D.49384>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 <= 9) goto <D.49380>; else goto <D.49379>;
    <D.49380>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    D.49012 = *D.49011;
    if (D.49012 == 0B) goto <D.49385>; else goto <D.49379>;
    <D.49385>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    *D.49011 = is_nullable_bb;
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, is_nullable_bb);
    goto <D.49381>;
    <D.49379>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 == 0B) goto <D.49386>; else goto <D.49388>;
    <D.49388>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 442) goto <D.49389>; else goto <D.49387>;
    <D.49389>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 759) goto <D.49390>; else goto <D.49387>;
    <D.49390>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 > 9) goto <D.49391>; else goto <D.49387>;
    <D.49391>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 > 9) goto <D.49392>; else goto <D.49387>;
    <D.49392>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 > 9) goto <D.49386>; else goto <D.49387>;
    <D.49386>:
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, is_nullable_bb);
    <D.49387>:
    <D.49381>:
    D.48895 = cfg->cbb;
    D.48895->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.48920 = cfg->mempool;
      box_sig = mono_mempool_alloc0 (D.48920, 24);
      D.49393 = mono_defaults.object_class;
      D.49394 = &D.49393->byval_arg;
      box_sig->ret = D.49394;
      box_sig->param_count = 1;
      D.49125 = &klass->byval_arg;
      box_sig->params[0] = D.49125;
      box_call = mono_emit_calli (cfg, box_sig, &val, addr, 0B, 0B);
      D.48920 = cfg->mempool;
      res = mono_mempool_alloc (D.48920, 80);
      res->data.op[1].const_val = 0;
      D.49137 = res->data.op[1].const_val;
      res->data.op[0].const_val = D.49137;
      res->prev = 0B;
      D.49138 = res->prev;
      res->next = D.49138;
      res->opcode = 424;
      res->flags = 0;
      res->type = 0;
      res->dreg = -1;
      res->sreg3 = -1;
      D.49139 = res->sreg3;
      res->sreg2 = D.49139;
      D.49140 = res->sreg2;
      res->sreg1 = D.49140;
      D.48931 = cfg->ip;
      res->cil_code = D.48931;
      res->dreg = dreg;
      D.49395 = box_call->dreg;
      res->sreg1 = D.49395;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49396>; else goto <D.49397>;
      <D.49396>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = res;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      res->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = res;
      goto <D.49398>;
      <D.49397>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = res;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49398>:
      res->type = 6;
      res->klass = klass;
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.48920 = cfg->mempool;
      ins = mono_mempool_alloc (D.48920, 80);
      ins->data.op[1].const_val = 0;
      D.49399 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.49399;
      ins->prev = 0B;
      D.49400 = ins->prev;
      ins->next = D.49400;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.49401 = ins->sreg3;
      ins->sreg2 = D.49401;
      D.49402 = ins->sreg2;
      ins->sreg1 = D.49402;
      D.48931 = cfg->ip;
      ins->cil_code = D.48931;
      if (1 != 0) goto <D.49403>; else goto <D.49404>;
      <D.49403>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49405 = D.48958;
      D.49406 = D.49405 + 1;
      cfg->num_bblocks = D.49406;
      D.49407 = (int) D.49405;
      falsebb->block_num = D.49407;
      ins->data.op[0].target_block = end_bb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49408>; else goto <D.49409>;
      <D.49408>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49410>;
      <D.49409>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49410>:
      D.49411 = falsebb->cil_code;
      if (D.49411 != 0B) goto <D.49412>; else goto <D.49413>;
      <D.49412>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49411 = falsebb->cil_code;
      D.49414 = (long int) D.49411;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49415 = D.49414 - D.48994;
      D.49416 = (long unsigned int) D.49415;
      D.49417 = D.49416 * 8;
      D.49418 = D.48991 + D.49417;
      *D.49418 = falsebb;
      <D.49413>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49422>; else goto <D.49419>;
      <D.49422>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49420>; else goto <D.49423>;
      <D.49423>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49420>; else goto <D.49424>;
      <D.49424>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49420>; else goto <D.49419>;
      <D.49420>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49425>; else goto <D.49419>;
      <D.49425>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49421>;
      <D.49419>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49426>; else goto <D.49428>;
      <D.49428>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49429>; else goto <D.49427>;
      <D.49429>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49430>; else goto <D.49427>;
      <D.49430>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49431>; else goto <D.49427>;
      <D.49431>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49432>; else goto <D.49427>;
      <D.49432>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49426>; else goto <D.49427>;
      <D.49426>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49427>:
      <D.49421>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49433>;
      <D.49404>:
      D.48920 = cfg->mempool;
      D.49434 = mono_mempool_alloc (D.48920, 16);
      ins->data.op[1].many_blocks = D.49434;
      D.49435 = ins->data.op[1].many_blocks;
      *D.49435 = end_bb;
      D.49435 = ins->data.op[1].many_blocks;
      D.49436 = D.49435 + 8;
      *D.49436 = 0B;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, end_bb);
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49437>; else goto <D.49438>;
      <D.49437>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.48950->next = ins;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      ins->prev = D.48950;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      goto <D.49439>;
      <D.49438>:
      D.48895 = cfg->cbb;
      D.48895 = cfg->cbb;
      D.48895->last_ins = ins;
      D.48950 = D.48895->last_ins;
      D.48895->code = D.48950;
      <D.49439>:
      D.48924 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.49028 = D.48924 & 34359738368;
      if (D.49028 == 0) goto <D.49440>; else goto <D.49441>;
      <D.49440>:
      D.48920 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.48920, 296);
      D.48958 = cfg->num_bblocks;
      D.49442 = D.48958;
      D.49443 = D.49442 + 1;
      cfg->num_bblocks = D.49443;
      D.49444 = (int) D.49442;
      falsebb->block_num = D.49444;
      D.49435 = ins->data.op[1].many_blocks;
      D.49436 = D.49435 + 8;
      *D.49436 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      D.49411 = falsebb->cil_code;
      if (D.49411 != 0B) goto <D.49445>; else goto <D.49446>;
      <D.49445>:
      D.48991 = cfg->cil_offset_to_bb;
      D.49411 = falsebb->cil_code;
      D.49414 = (long int) D.49411;
      D.48993 = cfg->cil_start;
      D.48994 = (long int) D.48993;
      D.49415 = D.49414 - D.48994;
      D.49416 = (long unsigned int) D.49415;
      D.49417 = D.49416 * 8;
      D.49418 = D.48991 + D.49417;
      *D.49418 = falsebb;
      <D.49446>:
      D.48999 = cfg->real_offset;
      falsebb->real_offset = D.48999;
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 != 0B) goto <D.49450>; else goto <D.49447>;
      <D.49450>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 <= 9) goto <D.49448>; else goto <D.49451>;
      <D.49451>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 <= 9) goto <D.49448>; else goto <D.49452>;
      <D.49452>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 <= 9) goto <D.49448>; else goto <D.49447>;
      <D.49448>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      D.49012 = *D.49011;
      if (D.49012 == 0B) goto <D.49453>; else goto <D.49447>;
      <D.49453>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49010 = D.48950->data.op[1].many_blocks;
      D.49011 = D.49010 + 8;
      *D.49011 = falsebb;
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      goto <D.49449>;
      <D.49447>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      if (D.48950 == 0B) goto <D.49454>; else goto <D.49456>;
      <D.49456>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 442) goto <D.49457>; else goto <D.49455>;
      <D.49457>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      if (D.49004 != 759) goto <D.49458>; else goto <D.49455>;
      <D.49458>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49005 = D.49004 + 64985;
      if (D.49005 > 9) goto <D.49459>; else goto <D.49455>;
      <D.49459>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49007 = D.49004 + 64878;
      if (D.49007 > 9) goto <D.49460>; else goto <D.49455>;
      <D.49460>:
      D.48895 = cfg->cbb;
      D.48950 = D.48895->last_ins;
      D.49004 = D.48950->opcode;
      D.49009 = D.49004 + 64888;
      if (D.49009 > 9) goto <D.49454>; else goto <D.49455>;
      <D.49454>:
      D.48895 = cfg->cbb;
      mono_link_bblock (cfg, D.48895, falsebb);
      <D.49455>:
      <D.49449>:
      D.48895 = cfg->cbb;
      D.48895->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.49461>;
      <D.49441>:
      D.48895 = cfg->cbb;
      D.48895->extended = 1;
      <D.49461>:
      <D.49433>:
    }
    D.49462 = end_bb->cil_code;
    if (D.49462 != 0B) goto <D.49463>; else goto <D.49464>;
    <D.49463>:
    D.48991 = cfg->cil_offset_to_bb;
    D.49462 = end_bb->cil_code;
    D.49465 = (long int) D.49462;
    D.48993 = cfg->cil_start;
    D.48994 = (long int) D.48993;
    D.49466 = D.49465 - D.48994;
    D.49467 = (long unsigned int) D.49466;
    D.49468 = D.49467 * 8;
    D.49469 = D.48991 + D.49468;
    *D.49469 = end_bb;
    <D.49464>:
    D.48999 = cfg->real_offset;
    end_bb->real_offset = D.48999;
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 != 0B) goto <D.49473>; else goto <D.49470>;
    <D.49473>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 <= 9) goto <D.49471>; else goto <D.49474>;
    <D.49474>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 <= 9) goto <D.49471>; else goto <D.49475>;
    <D.49475>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 <= 9) goto <D.49471>; else goto <D.49470>;
    <D.49471>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    D.49012 = *D.49011;
    if (D.49012 == 0B) goto <D.49476>; else goto <D.49470>;
    <D.49476>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49010 = D.48950->data.op[1].many_blocks;
    D.49011 = D.49010 + 8;
    *D.49011 = end_bb;
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, end_bb);
    goto <D.49472>;
    <D.49470>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    if (D.48950 == 0B) goto <D.49477>; else goto <D.49479>;
    <D.49479>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 442) goto <D.49480>; else goto <D.49478>;
    <D.49480>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    if (D.49004 != 759) goto <D.49481>; else goto <D.49478>;
    <D.49481>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49005 = D.49004 + 64985;
    if (D.49005 > 9) goto <D.49482>; else goto <D.49478>;
    <D.49482>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49007 = D.49004 + 64878;
    if (D.49007 > 9) goto <D.49483>; else goto <D.49478>;
    <D.49483>:
    D.48895 = cfg->cbb;
    D.48950 = D.48895->last_ins;
    D.49004 = D.48950->opcode;
    D.49009 = D.49004 + 64888;
    if (D.49009 > 9) goto <D.49477>; else goto <D.49478>;
    <D.49477>:
    D.48895 = cfg->cbb;
    mono_link_bblock (cfg, D.48895, end_bb);
    <D.49478>:
    <D.49472>:
    D.48895 = cfg->cbb;
    D.48895->next_bb = end_bb;
    cfg->cbb = end_bb;
    D.48895 = cfg->cbb;
    *out_cbb = D.48895;
    D.48902 = res;
    return D.48902;
  }
  <D.48956>:
  alloc = handle_alloc (cfg, klass, 1, context_used);
  if (alloc == 0B) goto <D.49484>; else goto <D.49485>;
  <D.49484>:
  D.48902 = 0B;
  return D.48902;
  <D.49485>:
  D.48920 = cfg->mempool;
  ins = mono_mempool_alloc (D.48920, 80);
  ins->data.op[1].const_val = 0;
  D.49123 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49123;
  ins->prev = 0B;
  D.49124 = ins->prev;
  ins->next = D.49124;
  D.49125 = &klass->byval_arg;
  D.49486 = mono_type_to_store_membase (cfg, D.49125);
  D.49487 = (short unsigned int) D.49486;
  ins->opcode = D.49487;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49128 = ins->sreg3;
  ins->sreg2 = D.49128;
  D.49129 = ins->sreg2;
  ins->sreg1 = D.49129;
  D.48931 = cfg->ip;
  ins->cil_code = D.48931;
  val.458 = val;
  D.49131 = val.458->dreg;
  ins->sreg1 = D.49131;
  D.49132 = alloc->dreg;
  ins->dreg = D.49132;
  ins->data.op[0].const_val = 16;
  D.49125 = &klass->byval_arg;
  type_to_eval_stack_type (cfg, D.49125, ins);
  D.49125 = &klass->byval_arg;
  D.49488 = mono_class_from_mono_type (D.49125);
  ins->klass = D.49488;
  D.48895 = cfg->cbb;
  D.48950 = D.48895->last_ins;
  if (D.48950 != 0B) goto <D.49489>; else goto <D.49490>;
  <D.49489>:
  D.48895 = cfg->cbb;
  D.48950 = D.48895->last_ins;
  D.48950->next = ins;
  D.48895 = cfg->cbb;
  D.48950 = D.48895->last_ins;
  ins->prev = D.48950;
  D.48895 = cfg->cbb;
  D.48895->last_ins = ins;
  goto <D.49491>;
  <D.49490>:
  D.48895 = cfg->cbb;
  D.48895 = cfg->cbb;
  D.48895->last_ins = ins;
  D.48950 = D.48895->last_ins;
  D.48895->code = D.48950;
  <D.49491>:
  D.48902 = alloc;
  return D.48902;
}


handle_unbox_nullable (struct MonoCompile * cfg, struct MonoInst * val, struct MonoClass * klass, int context_used)
{
  struct MonoMethod * D.49496;
  struct MonoInst * D.49497;
  struct MonoMethodSignature * D.49498;
  int pass_mrgctx.462;
  _Bool D.49500;
  long int D.49501;
  long int D.49502;
  int pass_vtable.463;
  struct MonoDomain * D.49508;
  struct MonoClass * D.49509;
  _Bool D.49510;
  long int D.49511;
  long int D.49512;
  struct MonoMemPool * D.49515;
  long int D.49516;
  struct MonoInst * D.49517;
  guint16 iftmp.464;
  long unsigned int D.49519;
  long unsigned int D.49520;
  int D.49524;
  int D.49525;
  const unsigned char * D.49526;
  long int D.49529;
  struct MonoInst * D.49530;
  int D.49531;
  int D.49532;
  struct MonoInst * iftmp.465;
  int D.49537;
  void * iftmp.466;
  unsigned int D.49543;
  int D.49544;
  struct MonoBasicBlock * D.49545;
  struct MonoInst * D.49546;
  struct MonoMethod * method;

  method = mono_class_get_method_from_name (klass, "Unbox", 1);
  if (context_used != 0) goto <D.49494>; else goto <D.49495>;
  <D.49494>:
  {
    struct MonoInst * rgctx;
    struct MonoInst * addr;

    addr = emit_get_rgctx_method (cfg, context_used, method, 6);
    D.49496 = cfg->current_method;
    rgctx = emit_get_rgctx (cfg, D.49496, context_used);
    D.49498 = mono_method_signature (method);
    D.49497 = mono_emit_calli (cfg, D.49498, &val, addr, 0B, rgctx);
    return D.49497;
  }
  <D.49495>:
  {
    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.462 = pass_mrgctx;
        D.49500 = pass_mrgctx.462 != 0;
        D.49501 = (long int) D.49500;
        D.49502 = __builtin_expect (D.49501, 0);
        if (D.49502 != 0) goto <D.49503>; else goto <D.49504>;
        <D.49503>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3578, "!pass_mrgctx");
        <D.49504>:
        pass_vtable.463 = pass_vtable;
        if (pass_vtable.463 != 0) goto <D.49506>; else goto <D.49507>;
        <D.49506>:
        {
          struct MonoVTable * vtable;

          D.49508 = cfg->domain;
          D.49509 = method->klass;
          vtable = mono_class_vtable (D.49508, D.49509);
          D.49510 = vtable == 0B;
          D.49511 = (long int) D.49510;
          D.49512 = __builtin_expect (D.49511, 0);
          if (D.49512 != 0) goto <D.49513>; else goto <D.49514>;
          <D.49513>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3583, "vtable");
          <D.49514>:
          D.49515 = cfg->mempool;
          rgctx_arg = mono_mempool_alloc (D.49515, 80);
          rgctx_arg->data.op[1].const_val = 0;
          D.49516 = rgctx_arg->data.op[1].const_val;
          rgctx_arg->data.op[0].const_val = D.49516;
          rgctx_arg->prev = 0B;
          D.49517 = rgctx_arg->prev;
          rgctx_arg->next = D.49517;
          D.49519 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.49520 = D.49519 & 274877906944;
          if (D.49520 != 0) goto <D.49521>; else goto <D.49522>;
          <D.49521>:
          iftmp.464 = 734;
          goto <D.49523>;
          <D.49522>:
          iftmp.464 = 363;
          <D.49523>:
          rgctx_arg->opcode = iftmp.464;
          rgctx_arg->flags = 0;
          rgctx_arg->type = 0;
          rgctx_arg->dreg = -1;
          rgctx_arg->sreg3 = -1;
          D.49524 = rgctx_arg->sreg3;
          rgctx_arg->sreg2 = D.49524;
          D.49525 = rgctx_arg->sreg2;
          rgctx_arg->sreg1 = D.49525;
          D.49526 = cfg->ip;
          rgctx_arg->cil_code = D.49526;
          D.49519 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.49520 = D.49519 & 274877906944;
          if (D.49520 != 0) goto <D.49527>; else goto <D.49528>;
          <D.49527>:
          {
            struct MonoInst * group;
            struct MonoInst * got_loc;

            got_loc = mono_get_got_var (cfg);
            D.49515 = cfg->mempool;
            group = mono_mempool_alloc (D.49515, 80);
            group->data.op[1].const_val = 0;
            D.49529 = group->data.op[1].const_val;
            group->data.op[0].const_val = D.49529;
            group->prev = 0B;
            D.49530 = group->prev;
            group->next = D.49530;
            group->opcode = 733;
            group->flags = 0;
            group->type = 0;
            group->dreg = -1;
            group->sreg3 = -1;
            D.49531 = group->sreg3;
            group->sreg2 = D.49531;
            D.49532 = group->sreg2;
            group->sreg1 = D.49532;
            D.49526 = cfg->ip;
            group->cil_code = D.49526;
            D.49519 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.49520 = D.49519 & 274877906944;
            if (D.49520 != 0) goto <D.49534>; else goto <D.49535>;
            <D.49534>:
            iftmp.465 = vtable->klass;
            goto <D.49536>;
            <D.49535>:
            iftmp.465 = vtable;
            <D.49536>:
            group->data.op[0].src = iftmp.465;
            group->data.op[1].src = 14B;
            D.49537 = got_loc->dreg;
            rgctx_arg->sreg1 = D.49537;
            rgctx_arg->data.op[1].p = group;
          }
          goto <D.49538>;
          <D.49528>:
          D.49519 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.49520 = D.49519 & 274877906944;
          if (D.49520 != 0) goto <D.49540>; else goto <D.49541>;
          <D.49540>:
          iftmp.466 = vtable->klass;
          goto <D.49542>;
          <D.49541>:
          iftmp.466 = vtable;
          <D.49542>:
          rgctx_arg->data.op[0].p = iftmp.466;
          rgctx_arg->data.op[1].src = 14B;
          <D.49538>:
          rgctx_arg->type = 3;
          D.49543 = alloc_dreg (cfg, 3);
          D.49544 = (int) D.49543;
          rgctx_arg->dreg = D.49544;
          D.49545 = cfg->cbb;
          D.49546 = D.49545->last_ins;
          if (D.49546 != 0B) goto <D.49547>; else goto <D.49548>;
          <D.49547>:
          D.49545 = cfg->cbb;
          D.49546 = D.49545->last_ins;
          D.49546->next = rgctx_arg;
          D.49545 = cfg->cbb;
          D.49546 = D.49545->last_ins;
          rgctx_arg->prev = D.49546;
          D.49545 = cfg->cbb;
          D.49545->last_ins = rgctx_arg;
          goto <D.49549>;
          <D.49548>:
          D.49545 = cfg->cbb;
          D.49545 = cfg->cbb;
          D.49545->last_ins = rgctx_arg;
          D.49546 = D.49545->last_ins;
          D.49545->code = D.49546;
          <D.49549>:
        }
        <D.49507>:
        D.49497 = mono_emit_method_call_full (cfg, method, 0B, 0, &val, 0B, 0B, rgctx_arg);
        return D.49497;
      }
    finally
      {
        pass_vtable = {CLOBBER};
        pass_mrgctx = {CLOBBER};
      }
  }
}


handle_unbox (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * sp, int context_used)
{
  unsigned int D.49552;
  unsigned int D.49553;
  unsigned int D.49554;
  unsigned int D.49555;
  struct MonoInst * D.49556;
  int D.49557;
  long unsigned int D.49560;
  long unsigned int D.49561;
  struct MonoMemPool * D.49564;
  long int D.49565;
  struct MonoInst * D.49566;
  int D.49567;
  int D.49568;
  const unsigned char * D.49569;
  struct MonoBasicBlock * D.49570;
  struct MonoInst * D.49571;
  long int D.49575;
  struct MonoInst * D.49576;
  int D.49577;
  int D.49578;
  long int D.49583;
  struct MonoInst * D.49584;
  int D.49585;
  int D.49586;
  unsigned char D.49587;
  long int D.49591;
  struct MonoInst * D.49592;
  int D.49593;
  int D.49594;
  unsigned char D.49598;
  _Bool D.49599;
  long int D.49600;
  long int D.49601;
  long int D.49604;
  struct MonoInst * D.49605;
  int D.49606;
  int D.49607;
  long int D.49611;
  struct MonoInst * D.49612;
  int D.49613;
  int D.49614;
  long int D.49618;
  struct MonoInst * D.49619;
  int D.49620;
  int D.49621;
  long int D.49625;
  struct MonoInst * D.49626;
  int D.49627;
  int D.49628;
  struct MonoClass * D.49636;
  long int D.49637;
  struct MonoInst * D.49638;
  int D.49639;
  int D.49640;
  int D.49641;
  long int D.49645;
  struct MonoInst * D.49646;
  int D.49647;
  int D.49648;
  long int D.49653;
  struct MonoInst * D.49654;
  int D.49655;
  int D.49656;
  unsigned int D.49657;
  int D.49658;
  struct MonoInst * D.49662;
  struct MonoInst * add;
  int obj_reg;
  int vtable_reg;
  int klass_reg;
  int eclass_reg;
  int rank_reg;

  D.49552 = alloc_dreg (cfg, 3);
  vtable_reg = (int) D.49552;
  D.49553 = alloc_dreg (cfg, 3);
  klass_reg = (int) D.49553;
  D.49554 = alloc_dreg (cfg, 3);
  eclass_reg = (int) D.49554;
  D.49555 = alloc_dreg (cfg, 1);
  rank_reg = (int) D.49555;
  D.49556 = *sp;
  obj_reg = D.49556->dreg;
  {
    struct MonoInst * inst;
    int __ins_flags;

    __ins_flags = 32;
    D.49557 = __ins_flags & 32;
    if (D.49557 != 0) goto <D.49558>; else goto <D.49559>;
    <D.49558>:
    D.49560 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.49561 = D.49560 & 64;
    if (D.49561 != 0) goto <D.49562>; else goto <D.49563>;
    <D.49562>:
    {
      struct MonoInst * inst;

      D.49564 = cfg->mempool;
      inst = mono_mempool_alloc (D.49564, 80);
      inst->data.op[1].const_val = 0;
      D.49565 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49565;
      inst->prev = 0B;
      D.49566 = inst->prev;
      inst->next = D.49566;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49567 = inst->sreg3;
      inst->sreg2 = D.49567;
      D.49568 = inst->sreg2;
      inst->sreg1 = D.49568;
      D.49569 = cfg->ip;
      inst->cil_code = D.49569;
      inst->dreg = -1;
      inst->sreg1 = obj_reg;
      inst->data.op[1].const_val = 0;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      if (D.49571 != 0B) goto <D.49572>; else goto <D.49573>;
      <D.49572>:
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      D.49571->next = inst;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      inst->prev = D.49571;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      goto <D.49574>;
      <D.49573>:
      D.49570 = cfg->cbb;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      D.49571 = D.49570->last_ins;
      D.49570->code = D.49571;
      <D.49574>:
    }
    {
      struct MonoInst * inst;

      D.49564 = cfg->mempool;
      inst = mono_mempool_alloc (D.49564, 80);
      inst->data.op[1].const_val = 0;
      D.49575 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49575;
      inst->prev = 0B;
      D.49576 = inst->prev;
      inst->next = D.49576;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49577 = inst->sreg3;
      inst->sreg2 = D.49577;
      D.49578 = inst->sreg2;
      inst->sreg1 = D.49578;
      D.49569 = cfg->ip;
      inst->cil_code = D.49569;
      inst->data.op[1].p = "NullReferenceException";
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      if (D.49571 != 0B) goto <D.49579>; else goto <D.49580>;
      <D.49579>:
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      D.49571->next = inst;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      inst->prev = D.49571;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      goto <D.49581>;
      <D.49580>:
      D.49570 = cfg->cbb;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      D.49571 = D.49570->last_ins;
      D.49570->code = D.49571;
      <D.49581>:
    }
    goto <D.49582>;
    <D.49563>:
    <D.49582>:
    <D.49559>:
    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49583 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49583;
    inst->prev = 0B;
    D.49584 = inst->prev;
    inst->next = D.49584;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49585 = inst->sreg3;
    inst->sreg2 = D.49585;
    D.49586 = inst->sreg2;
    inst->sreg1 = D.49586;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    inst->type = 1;
    D.49587 = (unsigned char) __ins_flags;
    inst->flags = D.49587;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49588>; else goto <D.49589>;
    <D.49588>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49590>;
    <D.49589>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49590>:
  }
  {
    struct MonoInst * inst;

    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49591 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49591;
    inst->prev = 0B;
    D.49592 = inst->prev;
    inst->next = D.49592;
    inst->opcode = 390;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49593 = inst->sreg3;
    inst->sreg2 = D.49593;
    D.49594 = inst->sreg2;
    inst->sreg1 = D.49594;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->dreg = rank_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 42;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49595>; else goto <D.49596>;
    <D.49595>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49597>;
    <D.49596>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49597>:
  }
  D.49598 = klass->rank;
  D.49599 = D.49598 != 0;
  D.49600 = (long int) D.49599;
  D.49601 = __builtin_expect (D.49600, 0);
  if (D.49601 != 0) goto <D.49602>; else goto <D.49603>;
  <D.49602>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3606, "klass->rank == 0");
  <D.49603>:
  {
    struct MonoInst * inst;

    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49604 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49604;
    inst->prev = 0B;
    D.49605 = inst->prev;
    inst->next = D.49605;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49606 = inst->sreg3;
    inst->sreg2 = D.49606;
    D.49607 = inst->sreg2;
    inst->sreg1 = D.49607;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->dreg = -1;
    inst->sreg1 = rank_reg;
    inst->data.op[1].const_val = 0;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49608>; else goto <D.49609>;
    <D.49608>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49610>;
    <D.49609>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49610>:
  }
  {
    struct MonoInst * inst;

    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49611 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49611;
    inst->prev = 0B;
    D.49612 = inst->prev;
    inst->next = D.49612;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49613 = inst->sreg3;
    inst->sreg2 = D.49613;
    D.49614 = inst->sreg2;
    inst->sreg1 = D.49614;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->data.op[1].p = "InvalidCastException";
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49615>; else goto <D.49616>;
    <D.49615>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49617>;
    <D.49616>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49617>:
  }
  {
    struct MonoInst * inst;

    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49618 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49618;
    inst->prev = 0B;
    D.49619 = inst->prev;
    inst->next = D.49619;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49620 = inst->sreg3;
    inst->sreg2 = D.49620;
    D.49621 = inst->sreg2;
    inst->sreg1 = D.49621;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->dreg = klass_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 0;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49622>; else goto <D.49623>;
    <D.49622>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49624>;
    <D.49623>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49624>:
  }
  {
    struct MonoInst * inst;

    D.49564 = cfg->mempool;
    inst = mono_mempool_alloc (D.49564, 80);
    inst->data.op[1].const_val = 0;
    D.49625 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49625;
    inst->prev = 0B;
    D.49626 = inst->prev;
    inst->next = D.49626;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49627 = inst->sreg3;
    inst->sreg2 = D.49627;
    D.49628 = inst->sreg2;
    inst->sreg1 = D.49628;
    D.49569 = cfg->ip;
    inst->cil_code = D.49569;
    inst->dreg = eclass_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 0;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    if (D.49571 != 0B) goto <D.49629>; else goto <D.49630>;
    <D.49629>:
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    D.49571->next = inst;
    D.49570 = cfg->cbb;
    D.49571 = D.49570->last_ins;
    inst->prev = D.49571;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    goto <D.49631>;
    <D.49630>:
    D.49570 = cfg->cbb;
    D.49570 = cfg->cbb;
    D.49570->last_ins = inst;
    D.49571 = D.49570->last_ins;
    D.49570->code = D.49571;
    <D.49631>:
  }
  if (context_used != 0) goto <D.49632>; else goto <D.49633>;
  <D.49632>:
  {
    struct MonoInst * element_class;

    D.49598 = klass->rank;
    D.49599 = D.49598 != 0;
    D.49600 = (long int) D.49599;
    D.49601 = __builtin_expect (D.49600, 0);
    if (D.49601 != 0) goto <D.49634>; else goto <D.49635>;
    <D.49634>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3619, "klass->rank == 0");
    <D.49635>:
    D.49636 = klass->element_class;
    element_class = emit_get_rgctx_klass (cfg, context_used, D.49636, 1);
    {
      struct MonoInst * inst;

      D.49564 = cfg->mempool;
      inst = mono_mempool_alloc (D.49564, 80);
      inst->data.op[1].const_val = 0;
      D.49637 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49637;
      inst->prev = 0B;
      D.49638 = inst->prev;
      inst->next = D.49638;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49639 = inst->sreg3;
      inst->sreg2 = D.49639;
      D.49640 = inst->sreg2;
      inst->sreg1 = D.49640;
      D.49569 = cfg->ip;
      inst->cil_code = D.49569;
      inst->dreg = -1;
      inst->sreg1 = eclass_reg;
      D.49641 = element_class->dreg;
      inst->sreg2 = D.49641;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      if (D.49571 != 0B) goto <D.49642>; else goto <D.49643>;
      <D.49642>:
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      D.49571->next = inst;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      inst->prev = D.49571;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      goto <D.49644>;
      <D.49643>:
      D.49570 = cfg->cbb;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      D.49571 = D.49570->last_ins;
      D.49570->code = D.49571;
      <D.49644>:
    }
    {
      struct MonoInst * inst;

      D.49564 = cfg->mempool;
      inst = mono_mempool_alloc (D.49564, 80);
      inst->data.op[1].const_val = 0;
      D.49645 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49645;
      inst->prev = 0B;
      D.49646 = inst->prev;
      inst->next = D.49646;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49647 = inst->sreg3;
      inst->sreg2 = D.49647;
      D.49648 = inst->sreg2;
      inst->sreg1 = D.49648;
      D.49569 = cfg->ip;
      inst->cil_code = D.49569;
      inst->data.op[1].p = "InvalidCastException";
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      if (D.49571 != 0B) goto <D.49649>; else goto <D.49650>;
      <D.49649>:
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      D.49571->next = inst;
      D.49570 = cfg->cbb;
      D.49571 = D.49570->last_ins;
      inst->prev = D.49571;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      goto <D.49651>;
      <D.49650>:
      D.49570 = cfg->cbb;
      D.49570 = cfg->cbb;
      D.49570->last_ins = inst;
      D.49571 = D.49570->last_ins;
      D.49570->code = D.49571;
      <D.49651>:
    }
  }
  goto <D.49652>;
  <D.49633>:
  D.49636 = klass->element_class;
  save_cast_details (cfg, D.49636, obj_reg, 0, 0B);
  D.49636 = klass->element_class;
  mini_emit_class_check (cfg, eclass_reg, D.49636);
  reset_cast_details (cfg);
  <D.49652>:
  D.49564 = cfg->mempool;
  add = mono_mempool_alloc (D.49564, 80);
  add->data.op[1].const_val = 0;
  D.49653 = add->data.op[1].const_val;
  add->data.op[0].const_val = D.49653;
  add->prev = 0B;
  D.49654 = add->prev;
  add->next = D.49654;
  add->opcode = 429;
  add->flags = 0;
  add->type = 0;
  add->dreg = -1;
  add->sreg3 = -1;
  D.49655 = add->sreg3;
  add->sreg2 = D.49655;
  D.49656 = add->sreg2;
  add->sreg1 = D.49656;
  D.49569 = cfg->ip;
  add->cil_code = D.49569;
  D.49657 = alloc_dreg (cfg, 5);
  D.49658 = (int) D.49657;
  add->dreg = D.49658;
  add->sreg1 = obj_reg;
  add->data.op[1].const_val = 16;
  D.49570 = cfg->cbb;
  D.49571 = D.49570->last_ins;
  if (D.49571 != 0B) goto <D.49659>; else goto <D.49660>;
  <D.49659>:
  D.49570 = cfg->cbb;
  D.49571 = D.49570->last_ins;
  D.49571->next = add;
  D.49570 = cfg->cbb;
  D.49571 = D.49570->last_ins;
  add->prev = D.49571;
  D.49570 = cfg->cbb;
  D.49570->last_ins = add;
  goto <D.49661>;
  <D.49660>:
  D.49570 = cfg->cbb;
  D.49570 = cfg->cbb;
  D.49570->last_ins = add;
  D.49571 = D.49570->last_ins;
  D.49570->code = D.49571;
  <D.49661>:
  add->type = 5;
  add->klass = klass;
  D.49662 = add;
  return D.49662;
}


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.49664;
  struct MonoException * ex;

  D.49664 = get_original_method (caller);
  ex = mono_security_core_clr_is_field_access_allowed (D.49664, field);
  if (ex != 0B) goto <D.49665>; else goto <D.49666>;
  <D.49665>:
  emit_throw_exception (cfg, ex);
  <D.49666>:
}


get_original_method (struct MonoMethod * method)
{
  long unsigned int D.49667;
  long unsigned int D.49668;
  struct MonoMethod * D.49671;

  D.49667 = BIT_FIELD_REF <*method, 64, 256>;
  D.49668 = D.49667 & 124;
  if (D.49668 == 0) goto <D.49669>; else goto <D.49670>;
  <D.49669>:
  D.49671 = method;
  return D.49671;
  <D.49670>:
  D.49667 = BIT_FIELD_REF <*method, 64, 256>;
  D.49668 = D.49667 & 124;
  if (D.49668 == 20) goto <D.49672>; else goto <D.49673>;
  <D.49672>:
  D.49671 = 0B;
  return D.49671;
  <D.49673>:
  D.49671 = mono_marshal_method_from_wrapper (method);
  return D.49671;
}


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.49675;
  _Bool D.49676;
  long int D.49677;
  long int D.49678;
  int D.49683;
  int D.49686;
  struct MonoMethod * D.49689;
  int D.49690;
  unsigned int D.49693;
  char * D.49696;
  char * D.49697;
  long unsigned int D.49698;
  long unsigned int D.49699;
  int D.49702;
  int D.49703;
  struct MonoLoaderError * D.49707;
  unsigned char D.49714;
  int D.49715;
  int D.49716;
  struct MonoType * D.49719;
  int D.49720;
  struct MonoMemPool * D.49723;
  short unsigned int D.49724;
  unsigned int D.49725;
  unsigned int D.49726;
  void * D.49727;
  struct MonoInst * * D.49728;
  long unsigned int D.49729;
  long unsigned int D.49730;
  struct MonoInst * * D.49731;
  struct MonoType * D.49732;
  struct MonoInst * D.49733;
  int D.49734;
  unsigned int D.49735;
  unsigned int D.49736;
  unsigned int D.49737;
  int D.49738;
  unsigned int D.49739;
  unsigned int D.49740;
  int D.49741;
  unsigned int D.49742;
  unsigned int D.49743;
  int D.49744;
  unsigned int D.49745;
  unsigned int D.49746;
  int D.49747;
  <unnamed-unsigned:1> D.49748;
  unsigned char D.49749;
  short unsigned int D.49752;
  int D.49753;
  int D.49754;
  int prev_cil_offset_to_bb_len.467;
  unsigned char D.49758;
  <unnamed-unsigned:1> D.49759;
  unsigned int D.49760;
  unsigned int costs.468;
  char * D.49767;
  char * D.49768;
  int D.49769;
  int D.49770;
  long int D.49771;
  struct MonoInst * D.49772;
  int D.49773;
  int D.49774;
  const unsigned char * D.49775;
  struct MonoInst * D.49776;
  short int D.49780;
  struct MonoBasicBlock * * D.49783;
  struct MonoBasicBlock * D.49784;
  short int D.49785;
  short int D.49792;
  struct MonoBasicBlock * * D.49794;
  struct MonoBasicBlock * D.49795;
  short int D.49796;
  struct MonoBasicBlock * * D.49806;
  struct MonoInst * D.49807;
  short unsigned int D.49810;
  int D.49813;
  int D.49814;
  struct MonoInst * * D.49819;
  long int D.49820;
  long unsigned int D.49821;
  long unsigned int D.49822;
  struct MonoInst * * D.49823;
  struct MonoInst * D.49824;
  struct MonoType * D.49825;
  unsigned int D.49826;
  short unsigned int D.49827;
  struct MonoClass * D.49828;
  int D.49829;
  unsigned char D.49830;
  <unnamed type> D.49831;
  unsigned int D.49832;
  int D.49833;
  short unsigned int D.49834;
  struct MonoClass * D.49837;
  struct MonoBasicBlock * D.49838;
  struct MonoInst * D.49839;
  struct MonoInst * * sp.469;
  struct GSList * D.49844;
  struct GSList * D.49845;
  char * D.49848;
  struct GSList * D.49849;
  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.49675 = cfg->exception_type;
  D.49676 = D.49675 != 0;
  D.49677 = (long int) D.49676;
  D.49678 = __builtin_expect (D.49677, 0);
  if (D.49678 != 0) goto <D.49679>; else goto <D.49680>;
  <D.49679>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 5768, "cfg->exception_type == MONO_EXCEPTION_NONE");
  <D.49680>:
  if (inline_always == 0) goto <D.49681>; else goto <D.49682>;
  <D.49681>:
  D.49683 = check_inline_called_method_name_limit (cmethod);
  if (D.49683 == 0) goto <D.49684>; else goto <D.49685>;
  <D.49684>:
  D.49686 = 0;
  return D.49686;
  <D.49685>:
  <D.49682>:
  if (inline_always == 0) goto <D.49687>; else goto <D.49688>;
  <D.49687>:
  D.49689 = cfg->method;
  D.49690 = check_inline_caller_method_name_limit (D.49689);
  if (D.49690 == 0) goto <D.49691>; else goto <D.49692>;
  <D.49691>:
  D.49686 = 0;
  return D.49686;
  <D.49692>:
  <D.49688>:
  D.49693 = cfg->verbose_level;
  if (D.49693 > 2) goto <D.49694>; else goto <D.49695>;
  <D.49694>:
  D.49689 = cfg->method;
  D.49696 = mono_method_full_name (D.49689, 1);
  D.49697 = mono_method_full_name (cmethod, 1);
  printf ("INLINE START %p %s -> %s\n", cmethod, D.49696, D.49697);
  <D.49695>:
  D.49698 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.49699 = D.49698 & 1;
  if (D.49699 == 0) goto <D.49700>; else goto <D.49701>;
  <D.49700>:
  D.49702 = cfg->stat_inlineable_methods;
  D.49703 = D.49702 + 1;
  cfg->stat_inlineable_methods = D.49703;
  cmethod->inline_info = 1;
  <D.49701>:
  cheader = mono_method_get_header (cmethod);
  if (cheader == 0B) goto <D.49704>; else goto <D.49706>;
  <D.49706>:
  D.49707 = mono_loader_get_last_error ();
  if (D.49707 != 0B) goto <D.49704>; else goto <D.49705>;
  <D.49704>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (cheader != 0B) goto <D.49708>; else goto <D.49709>;
    <D.49708>:
    mono_metadata_free_mh (cheader);
    <D.49709>:
    if (inline_always != 0) goto <D.49710>; else goto <D.49711>;
    <D.49710>:
    if (error != 0B) goto <D.49712>; else goto <D.49713>;
    <D.49712>:
    D.49714 = error->exception_type;
    D.49715 = (int) D.49714;
    mono_cfg_set_exception (cfg, D.49715);
    <D.49713>:
    <D.49711>:
    mono_loader_clear_error ();
    D.49686 = 0;
    return D.49686;
  }
  <D.49705>:
  D.49716 = mono_compile_is_broken (cfg, cmethod, 0);
  if (D.49716 != 0) goto <D.49717>; else goto <D.49718>;
  <D.49717>:
  mono_metadata_free_mh (cheader);
  D.49686 = 0;
  return D.49686;
  <D.49718>:
  D.49719 = fsig->ret;
  D.49720 = mono_type_is_void (D.49719);
  if (D.49720 == 0) goto <D.49721>; else goto <D.49722>;
  <D.49721>:
  D.49719 = fsig->ret;
  rvar = mono_compile_create_var (cfg, D.49719, 329);
  <D.49722>:
  prev_locals = cfg->locals;
  D.49723 = cfg->mempool;
  D.49724 = cheader->num_locals;
  D.49725 = (unsigned int) D.49724;
  D.49726 = D.49725 * 8;
  D.49727 = mono_mempool_alloc0 (D.49723, D.49726);
  cfg->locals = D.49727;
  i = 0;
  goto <D.27434>;
  <D.27433>:
  D.49728 = cfg->locals;
  D.49729 = (long unsigned int) i;
  D.49730 = D.49729 * 8;
  D.49731 = D.49728 + D.49730;
  D.49732 = cheader->locals[i];
  D.49733 = mono_compile_create_var (cfg, D.49732, 329);
  *D.49731 = D.49733;
  i = i + 1;
  <D.27434>:
  D.49724 = cheader->num_locals;
  D.49734 = (int) D.49724;
  if (D.49734 > i) goto <D.27433>; else goto <D.27435>;
  <D.27435>:
  D.49723 = cfg->mempool;
  sbblock = mono_mempool_alloc0 (D.49723, 296);
  D.49735 = cfg->num_bblocks;
  D.49736 = D.49735;
  D.49737 = D.49736 + 1;
  cfg->num_bblocks = D.49737;
  D.49738 = (int) D.49736;
  sbblock->block_num = D.49738;
  sbblock->real_offset = real_offset;
  D.49723 = cfg->mempool;
  ebblock = mono_mempool_alloc0 (D.49723, 296);
  D.49735 = cfg->num_bblocks;
  D.49739 = D.49735;
  D.49740 = D.49739 + 1;
  cfg->num_bblocks = D.49740;
  D.49741 = (int) D.49739;
  ebblock->block_num = D.49741;
  D.49735 = cfg->num_bblocks;
  D.49742 = D.49735;
  D.49743 = D.49742 + 1;
  cfg->num_bblocks = D.49743;
  D.49744 = (int) D.49742;
  ebblock->block_num = D.49744;
  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.49745 = cfg->inline_depth;
  D.49746 = D.49745 + 1;
  cfg->inline_depth = D.49746;
  prev_real_offset = cfg->real_offset;
  prev_cbb_hash = cfg->cbb_hash;
  prev_cil_offset_to_bb = cfg->cil_offset_to_bb;
  D.49747 = cfg->cil_offset_to_bb_len;
  prev_cil_offset_to_bb_len = (guint32) D.49747;
  prev_cil_start = cfg->cil_start;
  prev_cbb = cfg->cbb;
  prev_current_method = cfg->current_method;
  prev_generic_context = cfg->generic_context;
  D.49748 = cfg->ret_var_set;
  prev_ret_var_set = (gboolean) D.49748;
  D.49749 = *ip;
  if (D.49749 == 111) goto <D.49750>; else goto <D.49751>;
  <D.49750>:
  D.49752 = cmethod->flags;
  D.49753 = (int) D.49752;
  D.49754 = D.49753 & 16;
  if (D.49754 == 0) goto <D.49755>; else goto <D.49756>;
  <D.49755>:
  virtual = 1;
  <D.49756>:
  <D.49751>:
  costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
  D.49748 = cfg->ret_var_set;
  ret_var_set = (gboolean) D.49748;
  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.467 = (int) prev_cil_offset_to_bb_len;
  cfg->cil_offset_to_bb_len = prev_cil_offset_to_bb_len.467;
  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.49758 = (unsigned char) prev_ret_var_set;
  D.49759 = (<unnamed-unsigned:1>) D.49758;
  cfg->ret_var_set = D.49759;
  D.49745 = cfg->inline_depth;
  D.49760 = D.49745 + 4294967295;
  cfg->inline_depth = D.49760;
  costs.468 = (unsigned int) costs;
  if (costs.468 <= 59) goto <D.49761>; else goto <D.49764>;
  <D.49764>:
  if (inline_always != 0) goto <D.49761>; else goto <D.49762>;
  <D.49761>:
  D.49693 = cfg->verbose_level;
  if (D.49693 > 2) goto <D.49765>; else goto <D.49766>;
  <D.49765>:
  D.49689 = cfg->method;
  D.49767 = mono_method_full_name (D.49689, 1);
  D.49768 = mono_method_full_name (cmethod, 1);
  printf ("INLINE END %s -> %s\n", D.49767, D.49768);
  <D.49766>:
  D.49769 = cfg->stat_inlined_methods;
  D.49770 = D.49769 + 1;
  cfg->stat_inlined_methods = D.49770;
  D.49723 = cfg->mempool;
  ins = mono_mempool_alloc (D.49723, 80);
  ins->data.op[1].const_val = 0;
  D.49771 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49771;
  ins->prev = 0B;
  D.49772 = ins->prev;
  ins->next = D.49772;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49773 = ins->sreg3;
  ins->sreg2 = D.49773;
  D.49774 = ins->sreg2;
  ins->sreg1 = D.49774;
  D.49775 = cfg->ip;
  ins->cil_code = D.49775;
  D.49776 = prev_cbb->last_ins;
  if (D.49776 != 0B) goto <D.49777>; else goto <D.49778>;
  <D.49777>:
  D.49776 = prev_cbb->last_ins;
  D.49776->next = ins;
  D.49776 = prev_cbb->last_ins;
  ins->prev = D.49776;
  prev_cbb->last_ins = ins;
  goto <D.49779>;
  <D.49778>:
  prev_cbb->last_ins = ins;
  D.49776 = prev_cbb->last_ins;
  prev_cbb->code = D.49776;
  <D.49779>:
  prev_cbb->next_bb = sbblock;
  link_bblock (cfg, prev_cbb, sbblock);
  mono_merge_basic_blocks (cfg, prev_cbb, sbblock);
  D.49780 = prev_cbb->out_count;
  if (D.49780 == 1) goto <D.49781>; else goto <D.49782>;
  <D.49781>:
  D.49783 = prev_cbb->out_bb;
  D.49784 = *D.49783;
  D.49785 = D.49784->in_count;
  if (D.49785 == 1) goto <D.49786>; else goto <D.49787>;
  <D.49786>:
  D.49783 = prev_cbb->out_bb;
  D.49784 = *D.49783;
  if (D.49784 != ebblock) goto <D.49788>; else goto <D.49789>;
  <D.49788>:
  D.49783 = prev_cbb->out_bb;
  D.49784 = *D.49783;
  mono_merge_basic_blocks (cfg, prev_cbb, D.49784);
  <D.49789>:
  <D.49787>:
  <D.49782>:
  D.49792 = ebblock->in_count;
  if (D.49792 == 1) goto <D.49793>; else goto <D.49790>;
  <D.49793>:
  D.49794 = ebblock->in_bb;
  D.49795 = *D.49794;
  D.49796 = D.49795->out_count;
  if (D.49796 == 1) goto <D.49797>; else goto <D.49790>;
  <D.49797>:
  {
    struct MonoBasicBlock * prev;

    D.49794 = ebblock->in_bb;
    prev = *D.49794;
    mono_merge_basic_blocks (cfg, prev, ebblock);
    cfg->cbb = prev;
    D.49780 = prev_cbb->out_count;
    if (D.49780 == 1) goto <D.49798>; else goto <D.49799>;
    <D.49798>:
    D.49783 = prev_cbb->out_bb;
    D.49784 = *D.49783;
    D.49785 = D.49784->in_count;
    if (D.49785 == 1) goto <D.49800>; else goto <D.49801>;
    <D.49800>:
    D.49783 = prev_cbb->out_bb;
    D.49784 = *D.49783;
    if (D.49784 == prev) goto <D.49802>; else goto <D.49803>;
    <D.49802>:
    mono_merge_basic_blocks (cfg, prev_cbb, prev);
    cfg->cbb = prev_cbb;
    <D.49803>:
    <D.49801>:
    <D.49799>:
  }
  goto <D.49791>;
  <D.49790>:
  if (rvar != 0B) goto <D.49804>; else goto <D.49805>;
  <D.49804>:
  {
    struct MonoBasicBlock * bb;

    i = 0;
    goto <D.27439>;
    <D.27438>:
    D.49794 = ebblock->in_bb;
    D.49729 = (long unsigned int) i;
    D.49730 = D.49729 * 8;
    D.49806 = D.49794 + D.49730;
    bb = *D.49806;
    D.49807 = bb->last_ins;
    if (D.49807 != 0B) goto <D.49808>; else goto <D.49809>;
    <D.49808>:
    D.49807 = bb->last_ins;
    D.49810 = D.49807->opcode;
    if (D.49810 == 798) goto <D.49811>; else goto <D.49812>;
    <D.49811>:
    cfg->cbb = bb;
    D.49813 = rvar->dreg;
    D.49719 = fsig->ret;
    emit_init_rvar (cfg, D.49813, D.49719);
    <D.49812>:
    <D.49809>:
    i = i + 1;
    <D.27439>:
    D.49792 = ebblock->in_count;
    D.49814 = (int) D.49792;
    if (D.49814 > i) goto <D.27438>; else goto <D.27440>;
    <D.27440>:
  }
  <D.49805>:
  cfg->cbb = ebblock;
  <D.49791>:
  if (rvar != 0B) goto <D.49815>; else goto <D.49816>;
  <D.49815>:
  if (ret_var_set == 0) goto <D.49817>; else goto <D.49818>;
  <D.49817>:
  D.49813 = rvar->dreg;
  D.49719 = fsig->ret;
  emit_init_rvar (cfg, D.49813, D.49719);
  <D.49818>:
  D.49723 = cfg->mempool;
  ins = mono_mempool_alloc (D.49723, 80);
  ins->data.op[1].const_val = 0;
  D.49771 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49771;
  ins->prev = 0B;
  D.49772 = ins->prev;
  ins->next = D.49772;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49773 = ins->sreg3;
  ins->sreg2 = D.49773;
  D.49774 = ins->sreg2;
  ins->sreg1 = D.49774;
  D.49775 = cfg->ip;
  ins->cil_code = D.49775;
  D.49819 = cfg->varinfo;
  D.49820 = rvar->data.op[0].const_val;
  D.49821 = (long unsigned int) D.49820;
  D.49822 = D.49821 * 8;
  D.49823 = D.49819 + D.49822;
  D.49824 = *D.49823;
  D.49825 = D.49824->data.op[1].vtype;
  D.49826 = mono_type_to_regmove (cfg, D.49825);
  D.49827 = (short unsigned int) D.49826;
  ins->opcode = D.49827;
  D.49819 = cfg->varinfo;
  D.49820 = rvar->data.op[0].const_val;
  D.49821 = (long unsigned int) D.49820;
  D.49822 = D.49821 * 8;
  D.49823 = D.49819 + D.49822;
  D.49824 = *D.49823;
  D.49825 = D.49824->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.49825, ins);
  D.49819 = cfg->varinfo;
  D.49820 = rvar->data.op[0].const_val;
  D.49821 = (long unsigned int) D.49820;
  D.49822 = D.49821 * 8;
  D.49823 = D.49819 + D.49822;
  D.49824 = *D.49823;
  D.49828 = D.49824->klass;
  ins->klass = D.49828;
  D.49819 = cfg->varinfo;
  D.49820 = rvar->data.op[0].const_val;
  D.49821 = (long unsigned int) D.49820;
  D.49822 = D.49821 * 8;
  D.49823 = D.49819 + D.49822;
  D.49824 = *D.49823;
  D.49829 = D.49824->dreg;
  ins->sreg1 = D.49829;
  D.49830 = ins->type;
  D.49831 = (<unnamed type>) D.49830;
  D.49832 = alloc_dreg (cfg, D.49831);
  D.49833 = (int) D.49832;
  ins->dreg = D.49833;
  D.49834 = ins->opcode;
  if (D.49834 == 427) goto <D.49835>; else goto <D.49836>;
  <D.49835>:
  D.49819 = cfg->varinfo;
  D.49820 = rvar->data.op[0].const_val;
  D.49821 = (long unsigned int) D.49820;
  D.49822 = D.49821 * 8;
  D.49823 = D.49819 + D.49822;
  D.49824 = *D.49823;
  D.49825 = D.49824->data.op[1].vtype;
  D.49837 = mono_class_from_mono_type (D.49825);
  ins->klass = D.49837;
  <D.49836>:
  D.49838 = cfg->cbb;
  D.49839 = D.49838->last_ins;
  if (D.49839 != 0B) goto <D.49840>; else goto <D.49841>;
  <D.49840>:
  D.49838 = cfg->cbb;
  D.49839 = D.49838->last_ins;
  D.49839->next = ins;
  D.49838 = cfg->cbb;
  D.49839 = D.49838->last_ins;
  ins->prev = D.49839;
  D.49838 = cfg->cbb;
  D.49838->last_ins = ins;
  goto <D.49842>;
  <D.49841>:
  D.49838 = cfg->cbb;
  D.49838 = cfg->cbb;
  D.49838->last_ins = ins;
  D.49839 = D.49838->last_ins;
  D.49838->code = D.49839;
  <D.49842>:
  sp.469 = sp;
  sp = sp.469 + 8;
  *sp.469 = ins;
  <D.49816>:
  D.49723 = cfg->mempool;
  D.49844 = cfg->headers_to_free;
  D.49845 = g_slist_prepend_mempool (D.49723, D.49844, cheader);
  cfg->headers_to_free = D.49845;
  D.49686 = costs + 1;
  return D.49686;
  <D.49762>:
  D.49693 = cfg->verbose_level;
  if (D.49693 > 2) goto <D.49846>; else goto <D.49847>;
  <D.49846>:
  D.49848 = mono_method_full_name (cmethod, 1);
  printf ("INLINE ABORTED %s (cost %d)\n", D.49848, costs);
  <D.49847>:
  cfg->exception_type = 0;
  mono_loader_clear_error ();
  cfg->cbb = prev_cbb;
  D.49723 = cfg->mempool;
  D.49844 = cfg->headers_to_free;
  D.49849 = g_slist_prepend_mempool (D.49723, D.49844, cheader);
  cfg->headers_to_free = D.49849;
  D.49686 = 0;
  return D.49686;
}


check_inline_called_method_name_limit (struct MonoMethod * called_method)
{
  const char * limit.470;
  char D.49857;
  long unsigned int D.49860;
  gboolean D.49861;
  _Bool D.49862;
  int strncmp_result;
  static const char * limit = 0B;

  limit.470 = limit;
  if (limit.470 == 0B) goto <D.49852>; else goto <D.49853>;
  <D.49852>:
  {
    const char * limit_string;

    limit_string = monoeg_g_getenv ("MONO_INLINE_CALLED_METHOD_NAME_LIMIT");
    if (limit_string != 0B) goto <D.49854>; else goto <D.49855>;
    <D.49854>:
    limit = limit_string;
    goto <D.49856>;
    <D.49855>:
    limit = "";
    <D.49856>:
  }
  <D.49853>:
  limit.470 = limit;
  D.49857 = *limit.470;
  if (D.49857 != 0) goto <D.49858>; else goto <D.49859>;
  <D.49858>:
  {
    char * called_method_name;

    called_method_name = mono_method_full_name (called_method, 1);
    limit.470 = limit;
    limit.470 = limit;
    D.49860 = strlen (limit.470);
    strncmp_result = strncmp (called_method_name, limit.470, D.49860);
    monoeg_g_free (called_method_name);
    D.49862 = strncmp_result == 0;
    D.49861 = (gboolean) D.49862;
    return D.49861;
  }
  <D.49859>:
  D.49861 = 1;
  return D.49861;
}


check_inline_caller_method_name_limit (struct MonoMethod * caller_method)
{
  const char * limit.471;
  char D.49870;
  long unsigned int D.49873;
  gboolean D.49874;
  _Bool D.49875;
  int strncmp_result;
  static const char * limit = 0B;

  limit.471 = limit;
  if (limit.471 == 0B) goto <D.49865>; else goto <D.49866>;
  <D.49865>:
  {
    const char * limit_string;

    limit_string = monoeg_g_getenv ("MONO_INLINE_CALLER_METHOD_NAME_LIMIT");
    if (limit_string != 0B) goto <D.49867>; else goto <D.49868>;
    <D.49867>:
    limit = limit_string;
    goto <D.49869>;
    <D.49868>:
    limit = "";
    <D.49869>:
  }
  <D.49866>:
  limit.471 = limit;
  D.49870 = *limit.471;
  if (D.49870 != 0) goto <D.49871>; else goto <D.49872>;
  <D.49871>:
  {
    char * caller_method_name;

    caller_method_name = mono_method_full_name (caller_method, 1);
    limit.471 = limit;
    limit.471 = limit;
    D.49873 = strlen (limit.471);
    strncmp_result = strncmp (caller_method_name, limit.471, D.49873);
    monoeg_g_free (caller_method_name);
    D.49875 = strncmp_result == 0;
    D.49874 = (gboolean) D.49875;
    return D.49874;
  }
  <D.49872>:
  D.49874 = 1;
  return D.49874;
}


is_magic_tls_access (struct MonoClassField * field)
{
  int D.27689;
  int iftmp.472;
  int D.27688;
  const char[8] * D.49880;
  unsigned char D.49881;
  int D.49882;
  unsigned char D.49883;
  int D.49884;
  const unsigned char * D.49889;
  unsigned char D.49890;
  int D.49891;
  const unsigned char * D.49892;
  unsigned char D.49893;
  int D.49894;
  const unsigned char * D.49899;
  unsigned char D.49900;
  int D.49901;
  const unsigned char * D.49902;
  unsigned char D.49903;
  int D.49904;
  const unsigned char * D.49909;
  unsigned char D.49910;
  int D.49911;
  const unsigned char * D.49912;
  unsigned char D.49913;
  int D.49914;
  const char * D.49916;
  gboolean D.49919;
  int D.27698;
  int iftmp.473;
  int D.27697;
  struct MonoClass * D.49923;
  const char[14] * D.49924;
  unsigned char D.49925;
  int D.49926;
  unsigned char D.49927;
  int D.49928;
  const unsigned char * D.49933;
  unsigned char D.49934;
  int D.49935;
  const unsigned char * D.49936;
  unsigned char D.49937;
  int D.49938;
  const unsigned char * D.49943;
  unsigned char D.49944;
  int D.49945;
  const unsigned char * D.49946;
  unsigned char D.49947;
  int D.49948;
  const unsigned char * D.49953;
  unsigned char D.49954;
  int D.49955;
  const unsigned char * D.49956;
  unsigned char D.49957;
  int D.49958;
  const char * D.49960;
  struct MonoImage * D.49963;
  struct MonoImage * D.49964;
  _Bool D.49965;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = field->name;
      D.49880 = "tlsdata";
      D.49881 = MEM[(const unsigned char *)D.49880];
      D.49882 = (int) D.49881;
      D.49883 = *__s2;
      D.49884 = (int) D.49883;
      __result = D.49882 - D.49884;
      {
        if (__s2_len != 0) goto <D.49885>; else goto <D.49886>;
        <D.49885>:
        if (__result == 0) goto <D.49887>; else goto <D.49888>;
        <D.49887>:
        D.49889 = &MEM[(void *)"tlsdata" + 1B];
        D.49890 = *D.49889;
        D.49891 = (int) D.49890;
        D.49892 = __s2 + 1;
        D.49893 = *D.49892;
        D.49894 = (int) D.49893;
        __result = D.49891 - D.49894;
        if (__s2_len > 1) goto <D.49895>; else goto <D.49896>;
        <D.49895>:
        if (__result == 0) goto <D.49897>; else goto <D.49898>;
        <D.49897>:
        D.49899 = &MEM[(void *)"tlsdata" + 2B];
        D.49900 = *D.49899;
        D.49901 = (int) D.49900;
        D.49902 = __s2 + 2;
        D.49903 = *D.49902;
        D.49904 = (int) D.49903;
        __result = D.49901 - D.49904;
        if (__s2_len > 2) goto <D.49905>; else goto <D.49906>;
        <D.49905>:
        if (__result == 0) goto <D.49907>; else goto <D.49908>;
        <D.49907>:
        D.49909 = &MEM[(void *)"tlsdata" + 3B];
        D.49910 = *D.49909;
        D.49911 = (int) D.49910;
        D.49912 = __s2 + 3;
        D.49913 = *D.49912;
        D.49914 = (int) D.49913;
        __result = D.49911 - D.49914;
        <D.49908>:
        <D.49906>:
        <D.49898>:
        <D.49896>:
        <D.49888>:
        <D.49886>:
      }
      D.27688 = __result;
    }
    iftmp.472 = -D.27688;
    goto <D.49915>;
    <D.49879>:
    D.49916 = field->name;
    iftmp.472 = __builtin_strcmp (D.49916, "tlsdata");
    <D.49915>:
    D.27689 = iftmp.472;
  }
  if (D.27689 != 0) goto <D.49917>; else goto <D.49918>;
  <D.49917>:
  D.49919 = 0;
  return D.49919;
  <D.49918>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 13;
    if (__s2_len <= 3) goto <D.49921>; else goto <D.49922>;
    <D.49921>:
    {
      const unsigned char * __s2;
      int __result;

      D.49923 = field->parent;
      __s2 = D.49923->name;
      D.49924 = "ThreadLocal`1";
      D.49925 = MEM[(const unsigned char *)D.49924];
      D.49926 = (int) D.49925;
      D.49927 = *__s2;
      D.49928 = (int) D.49927;
      __result = D.49926 - D.49928;
      {
        if (__s2_len != 0) goto <D.49929>; else goto <D.49930>;
        <D.49929>:
        if (__result == 0) goto <D.49931>; else goto <D.49932>;
        <D.49931>:
        D.49933 = &MEM[(void *)"ThreadLocal`1" + 1B];
        D.49934 = *D.49933;
        D.49935 = (int) D.49934;
        D.49936 = __s2 + 1;
        D.49937 = *D.49936;
        D.49938 = (int) D.49937;
        __result = D.49935 - D.49938;
        if (__s2_len > 1) goto <D.49939>; else goto <D.49940>;
        <D.49939>:
        if (__result == 0) goto <D.49941>; else goto <D.49942>;
        <D.49941>:
        D.49943 = &MEM[(void *)"ThreadLocal`1" + 2B];
        D.49944 = *D.49943;
        D.49945 = (int) D.49944;
        D.49946 = __s2 + 2;
        D.49947 = *D.49946;
        D.49948 = (int) D.49947;
        __result = D.49945 - D.49948;
        if (__s2_len > 2) goto <D.49949>; else goto <D.49950>;
        <D.49949>:
        if (__result == 0) goto <D.49951>; else goto <D.49952>;
        <D.49951>:
        D.49953 = &MEM[(void *)"ThreadLocal`1" + 3B];
        D.49954 = *D.49953;
        D.49955 = (int) D.49954;
        D.49956 = __s2 + 3;
        D.49957 = *D.49956;
        D.49958 = (int) D.49957;
        __result = D.49955 - D.49958;
        <D.49952>:
        <D.49950>:
        <D.49942>:
        <D.49940>:
        <D.49932>:
        <D.49930>:
      }
      D.27697 = __result;
    }
    iftmp.473 = -D.27697;
    goto <D.49959>;
    <D.49922>:
    D.49923 = field->parent;
    D.49960 = D.49923->name;
    iftmp.473 = __builtin_strcmp (D.49960, "ThreadLocal`1");
    <D.49959>:
    D.27698 = iftmp.473;
  }
  if (D.27698 != 0) goto <D.49961>; else goto <D.49962>;
  <D.49961>:
  D.49919 = 0;
  return D.49919;
  <D.49962>:
  D.49923 = field->parent;
  D.49963 = D.49923->image;
  D.49964 = mono_defaults.corlib;
  D.49965 = D.49963 == D.49964;
  D.49919 = (gboolean) D.49965;
  return D.49919;
}


create_magic_tls_access (struct MonoCompile * cfg, struct MonoClassField * tls_field, struct MonoInst * * cached_tls_addr, struct MonoInst * thread_local)
{
  struct MonoInst * D.49967;
  struct MonoMemPool * D.49970;
  long int D.49971;
  struct MonoInst * D.49972;
  int D.49973;
  int D.49974;
  const unsigned char * D.49975;
  struct MonoInst * * D.49976;
  long int D.49977;
  long unsigned int D.49978;
  long unsigned int D.49979;
  struct MonoInst * * D.49980;
  struct MonoInst * D.49981;
  struct MonoType * D.49982;
  unsigned int D.49983;
  short unsigned int D.49984;
  struct MonoClass * D.49985;
  int D.49986;
  unsigned char D.49987;
  <unnamed type> D.49988;
  unsigned int D.49989;
  int D.49990;
  short unsigned int D.49991;
  struct MonoClass * D.49994;
  struct MonoBasicBlock * D.49995;
  struct MonoInst * D.49996;
  struct MonoInst * D.50000;
  struct MonoClass * D.50001;
  long int D.50002;
  struct MonoInst * D.50003;
  struct MonoType * D.50004;
  unsigned int D.50005;
  short unsigned int D.50006;
  int D.50007;
  int D.50008;
  int D.50009;
  int D.50010;
  long int D.50011;
  unsigned char D.50012;
  <unnamed type> D.50013;
  unsigned int D.50014;
  int D.50015;
  struct MonoClass * D.50025;
  int D.50026;
  struct MonoType * D.50027;
  struct MonoClass * D.50028;
  struct MonoType * D.50029;
  long int D.50030;
  struct MonoInst * D.50031;
  int D.50032;
  int D.50033;
  long int D.50034;
  long unsigned int D.50035;
  long unsigned int D.50036;
  struct MonoInst * * D.50037;
  struct MonoInst * D.50038;
  struct MonoType * D.50039;
  unsigned int D.50040;
  short unsigned int D.50041;
  struct MonoClass * D.50042;
  int D.50043;
  int D.50044;
  short unsigned int D.50045;
  struct MonoClass * D.50048;
  unsigned int D.50052;
  short unsigned int D.50053;
  unsigned int D.50054;
  int D.50055;
  struct MonoClass * D.50058;
  struct MonoInst * load;
  struct MonoInst * addr;
  struct MonoInst * temp;
  struct MonoInst * store;
  struct MonoInst * thread_ins;
  struct MonoClassField * offset_field;

  D.49967 = *cached_tls_addr;
  if (D.49967 != 0B) goto <D.49968>; else goto <D.49969>;
  <D.49968>:
  D.49970 = cfg->mempool;
  addr = mono_mempool_alloc (D.49970, 80);
  addr->data.op[1].const_val = 0;
  D.49971 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.49971;
  addr->prev = 0B;
  D.49972 = addr->prev;
  addr->next = D.49972;
  addr->opcode = 424;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.49973 = addr->sreg3;
  addr->sreg2 = D.49973;
  D.49974 = addr->sreg2;
  addr->sreg1 = D.49974;
  D.49975 = cfg->ip;
  addr->cil_code = D.49975;
  D.49976 = cfg->varinfo;
  D.49967 = *cached_tls_addr;
  D.49977 = D.49967->data.op[0].const_val;
  D.49978 = (long unsigned int) D.49977;
  D.49979 = D.49978 * 8;
  D.49980 = D.49976 + D.49979;
  D.49981 = *D.49980;
  D.49982 = D.49981->data.op[1].vtype;
  D.49983 = mono_type_to_regmove (cfg, D.49982);
  D.49984 = (short unsigned int) D.49983;
  addr->opcode = D.49984;
  D.49976 = cfg->varinfo;
  D.49967 = *cached_tls_addr;
  D.49977 = D.49967->data.op[0].const_val;
  D.49978 = (long unsigned int) D.49977;
  D.49979 = D.49978 * 8;
  D.49980 = D.49976 + D.49979;
  D.49981 = *D.49980;
  D.49982 = D.49981->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.49982, addr);
  D.49976 = cfg->varinfo;
  D.49967 = *cached_tls_addr;
  D.49977 = D.49967->data.op[0].const_val;
  D.49978 = (long unsigned int) D.49977;
  D.49979 = D.49978 * 8;
  D.49980 = D.49976 + D.49979;
  D.49981 = *D.49980;
  D.49985 = D.49981->klass;
  addr->klass = D.49985;
  D.49976 = cfg->varinfo;
  D.49967 = *cached_tls_addr;
  D.49977 = D.49967->data.op[0].const_val;
  D.49978 = (long unsigned int) D.49977;
  D.49979 = D.49978 * 8;
  D.49980 = D.49976 + D.49979;
  D.49981 = *D.49980;
  D.49986 = D.49981->dreg;
  addr->sreg1 = D.49986;
  D.49987 = addr->type;
  D.49988 = (<unnamed type>) D.49987;
  D.49989 = alloc_dreg (cfg, D.49988);
  D.49990 = (int) D.49989;
  addr->dreg = D.49990;
  D.49991 = addr->opcode;
  if (D.49991 == 427) goto <D.49992>; else goto <D.49993>;
  <D.49992>:
  D.49976 = cfg->varinfo;
  D.49967 = *cached_tls_addr;
  D.49977 = D.49967->data.op[0].const_val;
  D.49978 = (long unsigned int) D.49977;
  D.49979 = D.49978 * 8;
  D.49980 = D.49976 + D.49979;
  D.49981 = *D.49980;
  D.49982 = D.49981->data.op[1].vtype;
  D.49994 = mono_class_from_mono_type (D.49982);
  addr->klass = D.49994;
  <D.49993>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  if (D.49996 != 0B) goto <D.49997>; else goto <D.49998>;
  <D.49997>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  D.49996->next = addr;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  addr->prev = D.49996;
  D.49995 = cfg->cbb;
  D.49995->last_ins = addr;
  goto <D.49999>;
  <D.49998>:
  D.49995 = cfg->cbb;
  D.49995 = cfg->cbb;
  D.49995->last_ins = addr;
  D.49996 = D.49995->last_ins;
  D.49995->code = D.49996;
  <D.49999>:
  D.50000 = addr;
  return D.50000;
  <D.49969>:
  thread_ins = mono_get_thread_intrinsic (cfg);
  D.50001 = tls_field->parent;
  offset_field = mono_class_get_field_from_name (D.50001, "tls_offset");
  D.49970 = cfg->mempool;
  load = mono_mempool_alloc (D.49970, 80);
  load->data.op[1].const_val = 0;
  D.50002 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.50002;
  load->prev = 0B;
  D.50003 = load->prev;
  load->next = D.50003;
  D.50004 = offset_field->type;
  D.50005 = mono_type_to_load_membase (cfg, D.50004);
  D.50006 = (short unsigned int) D.50005;
  load->opcode = D.50006;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.50007 = load->sreg3;
  load->sreg2 = D.50007;
  D.50008 = load->sreg2;
  load->sreg1 = D.50008;
  D.49975 = cfg->ip;
  load->cil_code = D.49975;
  load->dreg = 0;
  D.50009 = thread_local->dreg;
  load->sreg1 = D.50009;
  D.50010 = offset_field->offset;
  D.50011 = (long int) D.50010;
  load->data.op[0].const_val = D.50011;
  load->type = 1;
  D.50004 = offset_field->type;
  type_to_eval_stack_type (cfg, D.50004, load);
  D.50012 = load->type;
  D.50013 = (<unnamed type>) D.50012;
  D.50014 = alloc_dreg (cfg, D.50013);
  D.50015 = (int) D.50014;
  load->dreg = D.50015;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  if (D.49996 != 0B) goto <D.50016>; else goto <D.50017>;
  <D.50016>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  D.49996->next = load;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  load->prev = D.49996;
  D.49995 = cfg->cbb;
  D.49995->last_ins = load;
  goto <D.50018>;
  <D.50017>:
  D.49995 = cfg->cbb;
  D.49995 = cfg->cbb;
  D.49995->last_ins = load;
  D.49996 = D.49995->last_ins;
  D.49995->code = D.49996;
  <D.50018>:
  if (thread_ins != 0B) goto <D.50019>; else goto <D.50020>;
  <D.50019>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  if (D.49996 != 0B) goto <D.50021>; else goto <D.50022>;
  <D.50021>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  D.49996->next = thread_ins;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  thread_ins->prev = D.49996;
  D.49995 = cfg->cbb;
  D.49995->last_ins = thread_ins;
  goto <D.50023>;
  <D.50022>:
  D.49995 = cfg->cbb;
  D.49995 = cfg->cbb;
  D.49995->last_ins = thread_ins;
  D.49996 = D.49995->last_ins;
  D.49995->code = D.49996;
  <D.50023>:
  goto <D.50024>;
  <D.50020>:
  {
    struct MonoMethod * thread_method;

    D.50025 = mono_get_thread_class ();
    thread_method = mono_class_get_method_from_name (D.50025, "CurrentInternalThread_internal", 0);
    thread_ins = mono_emit_method_call (cfg, thread_method, 0B, 0B);
  }
  <D.50024>:
  D.50026 = load->dreg;
  addr = emit_managed_static_data_access (cfg, thread_ins, D.50026);
  D.50027 = tls_field->type;
  D.50028 = mono_class_from_mono_type (D.50027);
  addr->klass = D.50028;
  addr->type = 5;
  D.50029 = type_from_stack_type (addr);
  temp = mono_compile_create_var (cfg, D.50029, 329);
  *cached_tls_addr = temp;
  D.49970 = cfg->mempool;
  store = mono_mempool_alloc (D.49970, 80);
  store->data.op[1].const_val = 0;
  D.50030 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.50030;
  store->prev = 0B;
  D.50031 = store->prev;
  store->next = D.50031;
  store->opcode = 424;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.50032 = store->sreg3;
  store->sreg2 = D.50032;
  D.50033 = store->sreg2;
  store->sreg1 = D.50033;
  D.49975 = cfg->ip;
  store->cil_code = D.49975;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50039 = D.50038->data.op[1].vtype;
  D.50040 = mono_type_to_regmove (cfg, D.50039);
  D.50041 = (short unsigned int) D.50040;
  store->opcode = D.50041;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50042 = D.50038->klass;
  store->klass = D.50042;
  D.50043 = addr->dreg;
  store->sreg1 = D.50043;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50044 = D.50038->dreg;
  store->dreg = D.50044;
  D.50045 = store->opcode;
  if (D.50045 == 427) goto <D.50046>; else goto <D.50047>;
  <D.50046>:
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50039 = D.50038->data.op[1].vtype;
  D.50048 = mono_class_from_mono_type (D.50039);
  store->klass = D.50048;
  <D.50047>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  if (D.49996 != 0B) goto <D.50049>; else goto <D.50050>;
  <D.50049>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  D.49996->next = store;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  store->prev = D.49996;
  D.49995 = cfg->cbb;
  D.49995->last_ins = store;
  goto <D.50051>;
  <D.50050>:
  D.49995 = cfg->cbb;
  D.49995 = cfg->cbb;
  D.49995->last_ins = store;
  D.49996 = D.49995->last_ins;
  D.49995->code = D.49996;
  <D.50051>:
  D.49970 = cfg->mempool;
  addr = mono_mempool_alloc (D.49970, 80);
  addr->data.op[1].const_val = 0;
  D.49971 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.49971;
  addr->prev = 0B;
  D.49972 = addr->prev;
  addr->next = D.49972;
  addr->opcode = 424;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.49973 = addr->sreg3;
  addr->sreg2 = D.49973;
  D.49974 = addr->sreg2;
  addr->sreg1 = D.49974;
  D.49975 = cfg->ip;
  addr->cil_code = D.49975;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50039 = D.50038->data.op[1].vtype;
  D.50052 = mono_type_to_regmove (cfg, D.50039);
  D.50053 = (short unsigned int) D.50052;
  addr->opcode = D.50053;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50039 = D.50038->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.50039, addr);
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50042 = D.50038->klass;
  addr->klass = D.50042;
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50044 = D.50038->dreg;
  addr->sreg1 = D.50044;
  D.49987 = addr->type;
  D.49988 = (<unnamed type>) D.49987;
  D.50054 = alloc_dreg (cfg, D.49988);
  D.50055 = (int) D.50054;
  addr->dreg = D.50055;
  D.49991 = addr->opcode;
  if (D.49991 == 427) goto <D.50056>; else goto <D.50057>;
  <D.50056>:
  D.49976 = cfg->varinfo;
  D.50034 = temp->data.op[0].const_val;
  D.50035 = (long unsigned int) D.50034;
  D.50036 = D.50035 * 8;
  D.50037 = D.49976 + D.50036;
  D.50038 = *D.50037;
  D.50039 = D.50038->data.op[1].vtype;
  D.50058 = mono_class_from_mono_type (D.50039);
  addr->klass = D.50058;
  <D.50057>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  if (D.49996 != 0B) goto <D.50059>; else goto <D.50060>;
  <D.50059>:
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  D.49996->next = addr;
  D.49995 = cfg->cbb;
  D.49996 = D.49995->last_ins;
  addr->prev = D.49996;
  D.49995 = cfg->cbb;
  D.49995->last_ins = addr;
  goto <D.50061>;
  <D.50060>:
  D.49995 = cfg->cbb;
  D.49995 = cfg->cbb;
  D.49995->last_ins = addr;
  D.49996 = D.49995->last_ins;
  D.49995->code = D.49996;
  <D.50061>:
  D.50000 = addr;
  return D.50000;
}


emit_managed_static_data_access (struct MonoCompile * cfg, struct MonoInst * thread_ins, int offset_reg)
{
  unsigned int D.50063;
  struct MonoMemPool * D.50064;
  long int D.50065;
  struct MonoInst * D.50066;
  int D.50067;
  int D.50068;
  const unsigned char * D.50069;
  int D.50070;
  struct MonoBasicBlock * D.50071;
  struct MonoInst * D.50072;
  unsigned int D.50076;
  long int D.50077;
  struct MonoInst * D.50078;
  int D.50079;
  int D.50080;
  long int D.50084;
  struct MonoInst * D.50085;
  int D.50086;
  int D.50087;
  long int D.50091;
  struct MonoInst * D.50092;
  int D.50093;
  int D.50094;
  long int D.50098;
  struct MonoInst * D.50099;
  int D.50100;
  int D.50101;
  unsigned int D.50105;
  long int D.50106;
  struct MonoInst * D.50107;
  int D.50108;
  int D.50109;
  unsigned int D.50113;
  long int D.50114;
  struct MonoInst * D.50115;
  int D.50116;
  int D.50117;
  unsigned int D.50121;
  long int D.50122;
  struct MonoInst * D.50123;
  int D.50124;
  int D.50125;
  struct MonoInst * D.50129;
  struct MonoInst * addr;
  int static_data_reg;
  int array_reg;
  int dreg;
  int offset2_reg;
  int idx_reg;

  D.50063 = alloc_ireg (cfg);
  static_data_reg = (int) D.50063;
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50065 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50065;
    inst->prev = 0B;
    D.50066 = inst->prev;
    inst->next = D.50066;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50067 = inst->sreg3;
    inst->sreg2 = D.50067;
    D.50068 = inst->sreg2;
    inst->sreg1 = D.50068;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = static_data_reg;
    D.50070 = thread_ins->dreg;
    inst->sreg1 = D.50070;
    inst->data.op[0].const_val = 96;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50073>; else goto <D.50074>;
    <D.50073>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50075>;
    <D.50074>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50075>:
  }
  D.50076 = alloc_ireg (cfg);
  idx_reg = (int) D.50076;
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50077 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50077;
    inst->prev = 0B;
    D.50078 = inst->prev;
    inst->next = D.50078;
    inst->opcode = 636;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50079 = inst->sreg3;
    inst->sreg2 = D.50079;
    D.50080 = inst->sreg2;
    inst->sreg1 = D.50080;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = idx_reg;
    inst->sreg1 = offset_reg;
    inst->data.op[1].const_val = 24;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50081>; else goto <D.50082>;
    <D.50081>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50083>;
    <D.50082>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50083>:
  }
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50084 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50084;
    inst->prev = 0B;
    D.50085 = inst->prev;
    inst->next = D.50085;
    inst->opcode = 626;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50086 = inst->sreg3;
    inst->sreg2 = D.50086;
    D.50087 = inst->sreg2;
    inst->sreg1 = D.50087;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = idx_reg;
    inst->sreg1 = idx_reg;
    inst->data.op[1].const_val = 1;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50088>; else goto <D.50089>;
    <D.50088>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50090>;
    <D.50089>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50090>:
  }
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50091 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50091;
    inst->prev = 0B;
    D.50092 = inst->prev;
    inst->next = D.50092;
    inst->opcode = 635;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50093 = inst->sreg3;
    inst->sreg2 = D.50093;
    D.50094 = inst->sreg2;
    inst->sreg1 = D.50094;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = idx_reg;
    inst->sreg1 = idx_reg;
    inst->data.op[1].const_val = 3;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50095>; else goto <D.50096>;
    <D.50095>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50097>;
    <D.50096>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50097>:
  }
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50098 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50098;
    inst->prev = 0B;
    D.50099 = inst->prev;
    inst->next = D.50099;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50100 = inst->sreg3;
    inst->sreg2 = D.50100;
    D.50101 = inst->sreg2;
    inst->sreg1 = D.50101;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = static_data_reg;
    inst->sreg1 = static_data_reg;
    inst->sreg2 = idx_reg;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50102>; else goto <D.50103>;
    <D.50102>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50104>;
    <D.50103>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50104>:
  }
  D.50105 = alloc_ireg (cfg);
  array_reg = (int) D.50105;
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50106 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50106;
    inst->prev = 0B;
    D.50107 = inst->prev;
    inst->next = D.50107;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50108 = inst->sreg3;
    inst->sreg2 = D.50108;
    D.50109 = inst->sreg2;
    inst->sreg1 = D.50109;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = array_reg;
    inst->sreg1 = static_data_reg;
    inst->data.op[0].const_val = 0;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50110>; else goto <D.50111>;
    <D.50110>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50112>;
    <D.50111>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50112>:
  }
  D.50113 = alloc_ireg (cfg);
  offset2_reg = (int) D.50113;
  {
    struct MonoInst * inst;

    D.50064 = cfg->mempool;
    inst = mono_mempool_alloc (D.50064, 80);
    inst->data.op[1].const_val = 0;
    D.50114 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50114;
    inst->prev = 0B;
    D.50115 = inst->prev;
    inst->next = D.50115;
    inst->opcode = 632;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50116 = inst->sreg3;
    inst->sreg2 = D.50116;
    D.50117 = inst->sreg2;
    inst->sreg1 = D.50117;
    D.50069 = cfg->ip;
    inst->cil_code = D.50069;
    inst->dreg = offset2_reg;
    inst->sreg1 = offset_reg;
    inst->data.op[1].const_val = 16777215;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    if (D.50072 != 0B) goto <D.50118>; else goto <D.50119>;
    <D.50118>:
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    D.50072->next = inst;
    D.50071 = cfg->cbb;
    D.50072 = D.50071->last_ins;
    inst->prev = D.50072;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    goto <D.50120>;
    <D.50119>:
    D.50071 = cfg->cbb;
    D.50071 = cfg->cbb;
    D.50071->last_ins = inst;
    D.50072 = D.50071->last_ins;
    D.50071->code = D.50072;
    <D.50120>:
  }
  D.50121 = alloc_ireg (cfg);
  dreg = (int) D.50121;
  D.50064 = cfg->mempool;
  addr = mono_mempool_alloc (D.50064, 80);
  addr->data.op[1].const_val = 0;
  D.50122 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.50122;
  addr->prev = 0B;
  D.50123 = addr->prev;
  addr->next = D.50123;
  addr->opcode = 479;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.50124 = addr->sreg3;
  addr->sreg2 = D.50124;
  D.50125 = addr->sreg2;
  addr->sreg1 = D.50125;
  D.50069 = cfg->ip;
  addr->cil_code = D.50069;
  addr->dreg = dreg;
  addr->sreg1 = array_reg;
  addr->sreg2 = offset2_reg;
  D.50071 = cfg->cbb;
  D.50072 = D.50071->last_ins;
  if (D.50072 != 0B) goto <D.50126>; else goto <D.50127>;
  <D.50126>:
  D.50071 = cfg->cbb;
  D.50072 = D.50071->last_ins;
  D.50072->next = addr;
  D.50071 = cfg->cbb;
  D.50072 = D.50071->last_ins;
  addr->prev = D.50072;
  D.50071 = cfg->cbb;
  D.50071->last_ins = addr;
  goto <D.50128>;
  <D.50127>:
  D.50071 = cfg->cbb;
  D.50071 = cfg->cbb;
  D.50071->last_ins = addr;
  D.50072 = D.50071->last_ins;
  D.50071->code = D.50072;
  <D.50128>:
  D.50129 = addr;
  return D.50129;
}


emit_generic_class_init (struct MonoCompile * cfg, struct MonoClass * klass)
{
  struct MonoInst * vtable_arg.474;
  struct MonoDomain * D.50135;
  struct MonoMemPool * D.50138;
  void * vtable_arg.475;
  struct MonoInst * vtable_arg.476;
  long int D.50141;
  struct MonoInst * D.50142;
  guint16 iftmp.477;
  long unsigned int D.50144;
  long unsigned int D.50145;
  int D.50149;
  int D.50150;
  const unsigned char * D.50151;
  long int D.50154;
  struct MonoInst * D.50155;
  int D.50156;
  int D.50157;
  struct MonoInst * iftmp.478;
  int D.50162;
  void * iftmp.479;
  unsigned int D.50168;
  int D.50169;
  struct MonoBasicBlock * D.50170;
  struct MonoInst * D.50171;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline_llvm.480;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline.481;
  int D.50180;
  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.50131>; else goto <D.50132>;
      <D.50131>:
      vtable_arg.474 = emit_get_rgctx_klass (cfg, context_used, klass, 2);
      vtable_arg = vtable_arg.474;
      goto <D.50134>;
      <D.50132>:
      {
        struct MonoVTable * vtable;

        D.50135 = cfg->domain;
        vtable = mono_class_vtable (D.50135, klass);
        if (vtable == 0B) goto <D.50136>; else goto <D.50137>;
        <D.50136>:
        return;
        <D.50137>:
        D.50138 = cfg->mempool;
        vtable_arg.475 = mono_mempool_alloc (D.50138, 80);
        vtable_arg = vtable_arg.475;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->data.op[1].const_val = 0;
        D.50141 = vtable_arg.476->data.op[1].const_val;
        vtable_arg.476->data.op[0].const_val = D.50141;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->prev = 0B;
        D.50142 = vtable_arg.476->prev;
        vtable_arg.476->next = D.50142;
        vtable_arg.476 = vtable_arg;
        D.50144 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50145 = D.50144 & 274877906944;
        if (D.50145 != 0) goto <D.50146>; else goto <D.50147>;
        <D.50146>:
        iftmp.477 = 734;
        goto <D.50148>;
        <D.50147>:
        iftmp.477 = 363;
        <D.50148>:
        vtable_arg.476->opcode = iftmp.477;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->flags = 0;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->type = 0;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->dreg = -1;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->sreg3 = -1;
        D.50149 = vtable_arg.476->sreg3;
        vtable_arg.476->sreg2 = D.50149;
        D.50150 = vtable_arg.476->sreg2;
        vtable_arg.476->sreg1 = D.50150;
        vtable_arg.476 = vtable_arg;
        D.50151 = cfg->ip;
        vtable_arg.476->cil_code = D.50151;
        D.50144 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50145 = D.50144 & 274877906944;
        if (D.50145 != 0) goto <D.50152>; else goto <D.50153>;
        <D.50152>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.50138 = cfg->mempool;
          group = mono_mempool_alloc (D.50138, 80);
          group->data.op[1].const_val = 0;
          D.50154 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.50154;
          group->prev = 0B;
          D.50155 = group->prev;
          group->next = D.50155;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.50156 = group->sreg3;
          group->sreg2 = D.50156;
          D.50157 = group->sreg2;
          group->sreg1 = D.50157;
          D.50151 = cfg->ip;
          group->cil_code = D.50151;
          D.50144 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.50145 = D.50144 & 274877906944;
          if (D.50145 != 0) goto <D.50159>; else goto <D.50160>;
          <D.50159>:
          iftmp.478 = vtable->klass;
          goto <D.50161>;
          <D.50160>:
          iftmp.478 = vtable;
          <D.50161>:
          group->data.op[0].src = iftmp.478;
          group->data.op[1].src = 14B;
          vtable_arg.476 = vtable_arg;
          D.50162 = got_loc->dreg;
          vtable_arg.476->sreg1 = D.50162;
          vtable_arg.476 = vtable_arg;
          vtable_arg.476->data.op[1].p = group;
        }
        goto <D.50163>;
        <D.50153>:
        vtable_arg.476 = vtable_arg;
        D.50144 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50145 = D.50144 & 274877906944;
        if (D.50145 != 0) goto <D.50165>; else goto <D.50166>;
        <D.50165>:
        iftmp.479 = vtable->klass;
        goto <D.50167>;
        <D.50166>:
        iftmp.479 = vtable;
        <D.50167>:
        vtable_arg.476->data.op[0].p = iftmp.479;
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->data.op[1].src = 14B;
        <D.50163>:
        vtable_arg.476 = vtable_arg;
        vtable_arg.476->type = 3;
        vtable_arg.476 = vtable_arg;
        D.50168 = alloc_dreg (cfg, 3);
        D.50169 = (int) D.50168;
        vtable_arg.476->dreg = D.50169;
        D.50170 = cfg->cbb;
        D.50171 = D.50170->last_ins;
        if (D.50171 != 0B) goto <D.50172>; else goto <D.50173>;
        <D.50172>:
        D.50170 = cfg->cbb;
        D.50171 = D.50170->last_ins;
        vtable_arg.476 = vtable_arg;
        D.50171->next = vtable_arg.476;
        vtable_arg.476 = vtable_arg;
        D.50170 = cfg->cbb;
        D.50171 = D.50170->last_ins;
        vtable_arg.476->prev = D.50171;
        D.50170 = cfg->cbb;
        vtable_arg.476 = vtable_arg;
        D.50170->last_ins = vtable_arg.476;
        goto <D.50174>;
        <D.50173>:
        D.50170 = cfg->cbb;
        D.50170 = cfg->cbb;
        vtable_arg.476 = vtable_arg;
        D.50170->last_ins = vtable_arg.476;
        D.50171 = D.50170->last_ins;
        D.50170->code = D.50171;
        <D.50174>:
      }
      <D.50134>:
      if (0 != 0) goto <D.50175>; else goto <D.50176>;
      <D.50175>:
      helper_sig_generic_class_init_trampoline_llvm.480 = helper_sig_generic_class_init_trampoline_llvm;
      call = mono_emit_abs_call (cfg, 36, 0B, helper_sig_generic_class_init_trampoline_llvm.480, &vtable_arg);
      goto <D.50178>;
      <D.50176>:
      helper_sig_generic_class_init_trampoline.481 = helper_sig_generic_class_init_trampoline;
      call = mono_emit_abs_call (cfg, 36, 0B, helper_sig_generic_class_init_trampoline.481, &vtable_arg);
      <D.50178>:
      vtable_arg.476 = vtable_arg;
      D.50180 = vtable_arg.476->dreg;
      mono_call_inst_add_outarg_reg (cfg, call, D.50180, 12, 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.50184;
  long unsigned int D.50185;
  _Bool D.50188;
  long int D.50189;
  long int D.50190;
  long unsigned int D.50193;
  long unsigned int D.50194;
  gboolean D.50197;
  unsigned int D.50198;
  unsigned int D.50199;
  struct MonoMethod * D.50202;
  int D.50205;
  short unsigned int D.50208;
  int D.50209;
  int D.50210;
  struct MonoClass * D.50213;

  D.50184 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.50185 = D.50184 & 274877906944;
  if (D.50185 == 0) goto <D.50186>; else goto <D.50187>;
  <D.50186>:
  D.50188 = vtable == 0B;
  D.50189 = (long int) D.50188;
  D.50190 = __builtin_expect (D.50189, 0);
  if (D.50190 != 0) goto <D.50191>; else goto <D.50192>;
  <D.50191>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4640, "vtable");
  <D.50192>:
  D.50193 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.50194 = D.50193 & 33554432;
  if (D.50194 != 0) goto <D.50195>; else goto <D.50196>;
  <D.50195>:
  D.50197 = 0;
  return D.50197;
  <D.50196>:
  <D.50187>:
  D.50198 = klass->flags;
  D.50199 = D.50198 & 1048576;
  if (D.50199 != 0) goto <D.50200>; else goto <D.50201>;
  <D.50200>:
  D.50202 = cfg->method;
  if (D.50202 == method) goto <D.50203>; else goto <D.50204>;
  <D.50203>:
  D.50197 = 0;
  return D.50197;
  <D.50204>:
  <D.50201>:
  D.50205 = mono_class_needs_cctor_run (klass, method);
  if (D.50205 == 0) goto <D.50206>; else goto <D.50207>;
  <D.50206>:
  D.50197 = 0;
  return D.50197;
  <D.50207>:
  D.50208 = method->flags;
  D.50209 = (int) D.50208;
  D.50210 = D.50209 & 16;
  if (D.50210 == 0) goto <D.50211>; else goto <D.50212>;
  <D.50211>:
  D.50213 = method->klass;
  if (D.50213 == klass) goto <D.50214>; else goto <D.50215>;
  <D.50214>:
  D.50197 = 0;
  return D.50197;
  <D.50215>:
  <D.50212>:
  D.50197 = 1;
  return D.50197;
}


set_exception_object (struct MonoCompile * cfg, struct MonoException * exception)
{
  void * * D.50219;
  void * D.50220;

  mono_cfg_set_exception (cfg, 13);
  if (0 != 0) goto <D.50217>; else goto <D.50218>;
  <D.50217>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6342, "sizeof (cfg->exception_ptr) == sizeof (MonoObject*)");
  <D.50218>:
  D.50219 = &cfg->exception_ptr;
  D.50220 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.50219, 8, D.50220);
  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.50221;
  unsigned char * D.50224;
  unsigned char D.50225;
  unsigned char * D.50228;
  unsigned char D.50229;
  unsigned char * D.50232;
  unsigned char D.50233;
  struct MonoClass * D.50236;
  struct MonoImage * D.50237;
  const char * D.50240;
  int D.27589;
  int iftmp.482;
  int D.27588;
  const char[16] * D.50248;
  unsigned char D.50249;
  int D.50250;
  unsigned char D.50251;
  int D.50252;
  const unsigned char * D.50257;
  unsigned char D.50258;
  int D.50259;
  const unsigned char * D.50260;
  unsigned char D.50261;
  int D.50262;
  const unsigned char * D.50267;
  unsigned char D.50268;
  int D.50269;
  const unsigned char * D.50270;
  unsigned char D.50271;
  int D.50272;
  const unsigned char * D.50277;
  unsigned char D.50278;
  int D.50279;
  const unsigned char * D.50280;
  unsigned char D.50281;
  int D.50282;
  const char * D.50284;
  int D.27598;
  int iftmp.483;
  int D.27597;
  struct MonoClass * D.50289;
  const char[15] * D.50290;
  unsigned char D.50291;
  int D.50292;
  unsigned char D.50293;
  int D.50294;
  const unsigned char * D.50299;
  unsigned char D.50300;
  int D.50301;
  const unsigned char * D.50302;
  unsigned char D.50303;
  int D.50304;
  const unsigned char * D.50309;
  unsigned char D.50310;
  int D.50311;
  const unsigned char * D.50312;
  unsigned char D.50313;
  int D.50314;
  const unsigned char * D.50319;
  unsigned char D.50320;
  int D.50321;
  const unsigned char * D.50322;
  unsigned char D.50323;
  int D.50324;
  const char * D.50326;
  struct MonoImage * D.50328;
  struct MonoImage * D.50329;
  struct MonoType * D.50330;
  struct MonoType * D.50331;
  unsigned char D.50332;
  int D.50333;
  unsigned int size.484;
  unsigned int D.50335;
  struct MonoType * D.50336;
  int D.50337;
  long unsigned int D.50340;
  long unsigned int D.50341;
  const guint32 * D.50344;
  unsigned int D.50345;
  unsigned int D.50346;
  unsigned int rva.485;
  long unsigned int D.50352;
  _Bool D.50354;
  long int D.50355;
  long int D.50356;

  D.50221 = *ip;
  if (D.50221 == 37) goto <D.50222>; else goto <D.50223>;
  <D.50222>:
  D.50224 = ip + 1;
  D.50225 = *D.50224;
  if (D.50225 == 208) goto <D.50226>; else goto <D.50227>;
  <D.50226>:
  D.50228 = ip + 5;
  D.50229 = *D.50228;
  if (D.50229 == 4) goto <D.50230>; else goto <D.50231>;
  <D.50230>:
  D.50232 = ip + 6;
  D.50233 = *D.50232;
  if (D.50233 == 40) goto <D.50234>; else goto <D.50235>;
  <D.50234>:
  {
    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
      {
        token = MEM[(const guint32 *)ip + 7B];
        field_token = MEM[(const guint32 *)ip + 2B];
        field_index = field_token & 16777215;
        size = 0;
        D.50236 = method->klass;
        D.50237 = D.50236->image;
        field = mono_field_from_token (D.50237, field_token, &dummy_class, 0B);
        if (field == 0B) goto <D.50238>; else goto <D.50239>;
        <D.50238>:
        D.50240 = 0B;
        return D.50240;
        <D.50239>:
        *out_field_token = field_token;
        cmethod = mini_get_method (0B, method, token, 0B, 0B);
        if (cmethod == 0B) goto <D.50241>; else goto <D.50242>;
        <D.50241>:
        D.50240 = 0B;
        return D.50240;
        <D.50242>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 15;
          if (__s2_len <= 3) goto <D.50246>; else goto <D.50247>;
          <D.50246>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = cmethod->name;
            D.50248 = "InitializeArray";
            D.50249 = MEM[(const unsigned char *)D.50248];
            D.50250 = (int) D.50249;
            D.50251 = *__s2;
            D.50252 = (int) D.50251;
            __result = D.50250 - D.50252;
            {
              if (__s2_len != 0) goto <D.50253>; else goto <D.50254>;
              <D.50253>:
              if (__result == 0) goto <D.50255>; else goto <D.50256>;
              <D.50255>:
              D.50257 = &MEM[(void *)"InitializeArray" + 1B];
              D.50258 = *D.50257;
              D.50259 = (int) D.50258;
              D.50260 = __s2 + 1;
              D.50261 = *D.50260;
              D.50262 = (int) D.50261;
              __result = D.50259 - D.50262;
              if (__s2_len > 1) goto <D.50263>; else goto <D.50264>;
              <D.50263>:
              if (__result == 0) goto <D.50265>; else goto <D.50266>;
              <D.50265>:
              D.50267 = &MEM[(void *)"InitializeArray" + 2B];
              D.50268 = *D.50267;
              D.50269 = (int) D.50268;
              D.50270 = __s2 + 2;
              D.50271 = *D.50270;
              D.50272 = (int) D.50271;
              __result = D.50269 - D.50272;
              if (__s2_len > 2) goto <D.50273>; else goto <D.50274>;
              <D.50273>:
              if (__result == 0) goto <D.50275>; else goto <D.50276>;
              <D.50275>:
              D.50277 = &MEM[(void *)"InitializeArray" + 3B];
              D.50278 = *D.50277;
              D.50279 = (int) D.50278;
              D.50280 = __s2 + 3;
              D.50281 = *D.50280;
              D.50282 = (int) D.50281;
              __result = D.50279 - D.50282;
              <D.50276>:
              <D.50274>:
              <D.50266>:
              <D.50264>:
              <D.50256>:
              <D.50254>:
            }
            D.27588 = __result;
          }
          iftmp.482 = -D.27588;
          goto <D.50283>;
          <D.50247>:
          D.50284 = cmethod->name;
          iftmp.482 = __builtin_strcmp (D.50284, "InitializeArray");
          <D.50283>:
          D.27589 = iftmp.482;
        }
        if (D.27589 != 0) goto <D.50243>; else goto <D.50285>;
        <D.50285>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 14;
          if (__s2_len <= 3) goto <D.50287>; else goto <D.50288>;
          <D.50287>:
          {
            const unsigned char * __s2;
            int __result;

            D.50289 = cmethod->klass;
            __s2 = D.50289->name;
            D.50290 = "RuntimeHelpers";
            D.50291 = MEM[(const unsigned char *)D.50290];
            D.50292 = (int) D.50291;
            D.50293 = *__s2;
            D.50294 = (int) D.50293;
            __result = D.50292 - D.50294;
            {
              if (__s2_len != 0) goto <D.50295>; else goto <D.50296>;
              <D.50295>:
              if (__result == 0) goto <D.50297>; else goto <D.50298>;
              <D.50297>:
              D.50299 = &MEM[(void *)"RuntimeHelpers" + 1B];
              D.50300 = *D.50299;
              D.50301 = (int) D.50300;
              D.50302 = __s2 + 1;
              D.50303 = *D.50302;
              D.50304 = (int) D.50303;
              __result = D.50301 - D.50304;
              if (__s2_len > 1) goto <D.50305>; else goto <D.50306>;
              <D.50305>:
              if (__result == 0) goto <D.50307>; else goto <D.50308>;
              <D.50307>:
              D.50309 = &MEM[(void *)"RuntimeHelpers" + 2B];
              D.50310 = *D.50309;
              D.50311 = (int) D.50310;
              D.50312 = __s2 + 2;
              D.50313 = *D.50312;
              D.50314 = (int) D.50313;
              __result = D.50311 - D.50314;
              if (__s2_len > 2) goto <D.50315>; else goto <D.50316>;
              <D.50315>:
              if (__result == 0) goto <D.50317>; else goto <D.50318>;
              <D.50317>:
              D.50319 = &MEM[(void *)"RuntimeHelpers" + 3B];
              D.50320 = *D.50319;
              D.50321 = (int) D.50320;
              D.50322 = __s2 + 3;
              D.50323 = *D.50322;
              D.50324 = (int) D.50323;
              __result = D.50321 - D.50324;
              <D.50318>:
              <D.50316>:
              <D.50308>:
              <D.50306>:
              <D.50298>:
              <D.50296>:
            }
            D.27597 = __result;
          }
          iftmp.483 = -D.27597;
          goto <D.50325>;
          <D.50288>:
          D.50289 = cmethod->klass;
          D.50326 = D.50289->name;
          iftmp.483 = __builtin_strcmp (D.50326, "RuntimeHelpers");
          <D.50325>:
          D.27598 = iftmp.483;
        }
        if (D.27598 != 0) goto <D.50243>; else goto <D.50327>;
        <D.50327>:
        D.50289 = cmethod->klass;
        D.50328 = D.50289->image;
        D.50329 = mono_defaults.corlib;
        if (D.50328 != D.50329) goto <D.50243>; else goto <D.50244>;
        <D.50243>:
        D.50240 = 0B;
        return D.50240;
        <D.50244>:
        D.50330 = &klass->byval_arg;
        D.50331 = mono_type_get_underlying_type (D.50330);
        D.50332 = D.50331->type;
        D.50333 = (int) D.50332;
        switch (D.50333) <default: <D.27612>, case 2: <D.27599>, case 3: <D.27603>, case 4: <D.27600>, case 5: <D.27601>, case 6: <D.27604>, case 7: <D.27605>, case 8: <D.27606>, case 9: <D.27607>, case 10: <D.27610>, case 11: <D.27611>, case 12: <D.27608>, case 13: <D.27609>>
        <D.27599>:
        <D.27600>:
        <D.27601>:
        size = 1;
        goto <D.27602>;
        <D.27603>:
        <D.27604>:
        <D.27605>:
        size = 2;
        goto <D.27602>;
        <D.27606>:
        <D.27607>:
        <D.27608>:
        size = 4;
        goto <D.27602>;
        <D.27609>:
        <D.27610>:
        <D.27611>:
        size = 8;
        goto <D.27602>;
        <D.27612>:
        D.50240 = 0B;
        return D.50240;
        <D.27602>:
        size.484 = (unsigned int) size;
        D.50335 = size.484 * len;
        size = (int) D.50335;
        D.50336 = field->type;
        D.50337 = mono_type_size (D.50336, &dummy_align);
        if (D.50337 < size) goto <D.50338>; else goto <D.50339>;
        <D.50338>:
        D.50240 = 0B;
        return D.50240;
        <D.50339>:
        *out_size = size;
        D.50236 = method->klass;
        D.50237 = D.50236->image;
        D.50340 = BIT_FIELD_REF <*D.50237, 64, 192>;
        D.50341 = D.50340 & 34359738368;
        if (D.50341 == 0) goto <D.50342>; else goto <D.50343>;
        <D.50342>:
        D.50344 = ip + 2;
        D.50345 = *D.50344;
        field_index = D.50345 & 16777215;
        D.50236 = method->klass;
        D.50237 = D.50236->image;
        D.50346 = field_index + 4294967295;
        mono_metadata_field_info (D.50237, D.50346, 0B, &rva, 0B);
        D.50236 = method->klass;
        D.50237 = D.50236->image;
        rva.485 = rva;
        data_ptr = mono_image_rva_map (D.50237, rva.485);
        if (aot != 0) goto <D.50348>; else goto <D.50349>;
        <D.50348>:
        if (data_ptr != 0B) goto <D.50350>; else goto <D.50351>;
        <D.50350>:
        rva.485 = rva;
        D.50352 = (long unsigned int) rva.485;
        D.50240 = (const char *) D.50352;
        return D.50240;
        <D.50351>:
        <D.50349>:
        goto <D.50353>;
        <D.50343>:
        D.50354 = aot != 0;
        D.50355 = (long int) D.50354;
        D.50356 = __builtin_expect (D.50355, 0);
        if (D.50356 != 0) goto <D.50357>; else goto <D.50358>;
        <D.50357>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6312, "!aot");
        <D.50358>:
        data_ptr = mono_field_get_data (field);
        <D.50353>:
        D.50240 = data_ptr;
        return D.50240;
      }
    finally
      {
        rva = {CLOBBER};
        dummy_class = {CLOBBER};
        dummy_align = {CLOBBER};
      }
  }
  <D.50235>:
  <D.50231>:
  <D.50227>:
  <D.50223>:
  D.50240 = 0B;
  return D.50240;
}


mini_emit_check_array_type (struct MonoCompile * cfg, struct MonoInst * obj, struct MonoClass * array_class)
{
  unsigned int D.50361;
  int D.50362;
  int D.50363;
  long unsigned int D.50366;
  long unsigned int D.50367;
  struct MonoMemPool * D.50370;
  long int D.50371;
  struct MonoInst * D.50372;
  int D.50373;
  int D.50374;
  const unsigned char * D.50375;
  struct MonoBasicBlock * D.50376;
  struct MonoInst * D.50377;
  long int D.50381;
  struct MonoInst * D.50382;
  int D.50383;
  int D.50384;
  long int D.50389;
  struct MonoInst * D.50390;
  int D.50391;
  int D.50392;
  unsigned char D.50393;
  unsigned int D.50397;
  unsigned int D.50398;
  unsigned int D.50401;
  long int D.50402;
  struct MonoInst * D.50403;
  int D.50404;
  int D.50405;
  long unsigned int D.50409;
  long unsigned int D.50410;
  unsigned int D.50413;
  long int D.50414;
  struct MonoInst * D.50415;
  guint16 iftmp.486;
  int D.50420;
  int D.50421;
  long int D.50424;
  struct MonoInst * D.50425;
  int D.50426;
  int D.50427;
  int D.50428;
  unsigned int D.50430;
  int D.50431;
  long int D.50435;
  struct MonoInst * D.50436;
  int D.50437;
  int D.50438;
  long int D.50443;
  struct MonoInst * D.50444;
  int D.50445;
  int D.50446;
  long int array_class.487;
  long int D.50454;
  struct MonoInst * D.50455;
  int D.50456;
  int D.50457;
  int D.50458;
  struct MonoDomain * D.50465;
  unsigned int D.50468;
  long int D.50469;
  struct MonoInst * D.50470;
  guint16 iftmp.488;
  int D.50475;
  int D.50476;
  long int D.50479;
  struct MonoInst * D.50480;
  int D.50481;
  int D.50482;
  struct MonoInst * iftmp.489;
  int D.50487;
  void * iftmp.490;
  unsigned int D.50493;
  int D.50494;
  long int D.50498;
  struct MonoInst * D.50499;
  int D.50500;
  int D.50501;
  long int D.50508;
  struct MonoInst * D.50509;
  int D.50510;
  int D.50511;
  long int vtable.491;
  long int D.50516;
  struct MonoInst * D.50517;
  int D.50518;
  int D.50519;
  int vtable_reg;
  int context_used;

  D.50361 = alloc_preg (cfg);
  vtable_reg = (int) D.50361;
  context_used = mini_class_check_context_used (cfg, array_class);
  D.50362 = obj->dreg;
  save_cast_details (cfg, array_class, D.50362, 0, 0B);
  {
    struct MonoInst * inst;
    int __ins_flags;

    __ins_flags = 32;
    D.50363 = __ins_flags & 32;
    if (D.50363 != 0) goto <D.50364>; else goto <D.50365>;
    <D.50364>:
    D.50366 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.50367 = D.50366 & 64;
    if (D.50367 != 0) goto <D.50368>; else goto <D.50369>;
    <D.50368>:
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50371 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50371;
      inst->prev = 0B;
      D.50372 = inst->prev;
      inst->next = D.50372;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50373 = inst->sreg3;
      inst->sreg2 = D.50373;
      D.50374 = inst->sreg2;
      inst->sreg1 = D.50374;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = -1;
      D.50362 = obj->dreg;
      inst->sreg1 = D.50362;
      inst->data.op[1].const_val = 0;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50378>; else goto <D.50379>;
      <D.50378>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50380>;
      <D.50379>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50380>:
    }
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50381 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50381;
      inst->prev = 0B;
      D.50382 = inst->prev;
      inst->next = D.50382;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50383 = inst->sreg3;
      inst->sreg2 = D.50383;
      D.50384 = inst->sreg2;
      inst->sreg1 = D.50384;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->data.op[1].p = "NullReferenceException";
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50385>; else goto <D.50386>;
      <D.50385>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50387>;
      <D.50386>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50387>:
    }
    goto <D.50388>;
    <D.50369>:
    <D.50388>:
    <D.50365>:
    D.50370 = cfg->mempool;
    inst = mono_mempool_alloc (D.50370, 80);
    inst->data.op[1].const_val = 0;
    D.50389 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50389;
    inst->prev = 0B;
    D.50390 = inst->prev;
    inst->next = D.50390;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50391 = inst->sreg3;
    inst->sreg2 = D.50391;
    D.50392 = inst->sreg2;
    inst->sreg1 = D.50392;
    D.50375 = cfg->ip;
    inst->cil_code = D.50375;
    inst->dreg = vtable_reg;
    D.50362 = obj->dreg;
    inst->sreg1 = D.50362;
    inst->data.op[0].const_val = 0;
    inst->type = 1;
    D.50393 = (unsigned char) __ins_flags;
    inst->flags = D.50393;
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    if (D.50377 != 0B) goto <D.50394>; else goto <D.50395>;
    <D.50394>:
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    D.50377->next = inst;
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    inst->prev = D.50377;
    D.50376 = cfg->cbb;
    D.50376->last_ins = inst;
    goto <D.50396>;
    <D.50395>:
    D.50376 = cfg->cbb;
    D.50376 = cfg->cbb;
    D.50376->last_ins = inst;
    D.50377 = D.50376->last_ins;
    D.50376->code = D.50377;
    <D.50396>:
  }
  D.50397 = cfg->opt;
  D.50398 = D.50397 & 512;
  if (D.50398 != 0) goto <D.50399>; else goto <D.50400>;
  <D.50399>:
  {
    int class_reg;

    D.50401 = alloc_preg (cfg);
    class_reg = (int) D.50401;
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50402 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50402;
      inst->prev = 0B;
      D.50403 = inst->prev;
      inst->next = D.50403;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50404 = inst->sreg3;
      inst->sreg2 = D.50404;
      D.50405 = inst->sreg2;
      inst->sreg1 = D.50405;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = class_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50406>; else goto <D.50407>;
      <D.50406>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50408>;
      <D.50407>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50408>:
    }
    D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.50410 = D.50409 & 274877906944;
    if (D.50410 != 0) goto <D.50411>; else goto <D.50412>;
    <D.50411>:
    {
      int klass_reg;

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

        D.50370 = cfg->mempool;
        inst = mono_mempool_alloc (D.50370, 80);
        inst->data.op[1].const_val = 0;
        D.50414 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50414;
        inst->prev = 0B;
        D.50415 = inst->prev;
        inst->next = D.50415;
        D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50410 = D.50409 & 274877906944;
        if (D.50410 != 0) goto <D.50417>; else goto <D.50418>;
        <D.50417>:
        iftmp.486 = 734;
        goto <D.50419>;
        <D.50418>:
        iftmp.486 = 363;
        <D.50419>:
        inst->opcode = iftmp.486;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50420 = inst->sreg3;
        inst->sreg2 = D.50420;
        D.50421 = inst->sreg2;
        inst->sreg1 = D.50421;
        D.50375 = cfg->ip;
        inst->cil_code = D.50375;
        D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50410 = D.50409 & 274877906944;
        if (D.50410 != 0) goto <D.50422>; else goto <D.50423>;
        <D.50422>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.50370 = cfg->mempool;
          group = mono_mempool_alloc (D.50370, 80);
          group->data.op[1].const_val = 0;
          D.50424 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.50424;
          group->prev = 0B;
          D.50425 = group->prev;
          group->next = D.50425;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.50426 = group->sreg3;
          group->sreg2 = D.50426;
          D.50427 = group->sreg2;
          group->sreg1 = D.50427;
          D.50375 = cfg->ip;
          group->cil_code = D.50375;
          group->data.op[0].src = array_class;
          group->data.op[1].src = 11B;
          D.50428 = got_loc->dreg;
          inst->sreg1 = D.50428;
          inst->data.op[1].p = group;
        }
        goto <D.50429>;
        <D.50423>:
        inst->data.op[0].p = array_class;
        inst->data.op[1].src = 11B;
        <D.50429>:
        inst->type = 3;
        D.50430 = alloc_dreg (cfg, 3);
        D.50431 = (int) D.50430;
        inst->dreg = D.50431;
        inst->dreg = klass_reg;
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        if (D.50377 != 0B) goto <D.50432>; else goto <D.50433>;
        <D.50432>:
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        D.50377->next = inst;
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        inst->prev = D.50377;
        D.50376 = cfg->cbb;
        D.50376->last_ins = inst;
        goto <D.50434>;
        <D.50433>:
        D.50376 = cfg->cbb;
        D.50376 = cfg->cbb;
        D.50376->last_ins = inst;
        D.50377 = D.50376->last_ins;
        D.50376->code = D.50377;
        <D.50434>:
      }
      {
        struct MonoInst * inst;

        D.50370 = cfg->mempool;
        inst = mono_mempool_alloc (D.50370, 80);
        inst->data.op[1].const_val = 0;
        D.50435 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50435;
        inst->prev = 0B;
        D.50436 = inst->prev;
        inst->next = D.50436;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50437 = inst->sreg3;
        inst->sreg2 = D.50437;
        D.50438 = inst->sreg2;
        inst->sreg1 = D.50438;
        D.50375 = cfg->ip;
        inst->cil_code = D.50375;
        inst->dreg = -1;
        inst->sreg1 = class_reg;
        inst->sreg2 = klass_reg;
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        if (D.50377 != 0B) goto <D.50439>; else goto <D.50440>;
        <D.50439>:
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        D.50377->next = inst;
        D.50376 = cfg->cbb;
        D.50377 = D.50376->last_ins;
        inst->prev = D.50377;
        D.50376 = cfg->cbb;
        D.50376->last_ins = inst;
        goto <D.50441>;
        <D.50440>:
        D.50376 = cfg->cbb;
        D.50376 = cfg->cbb;
        D.50376->last_ins = inst;
        D.50377 = D.50376->last_ins;
        D.50376->code = D.50377;
        <D.50441>:
      }
    }
    goto <D.50442>;
    <D.50412>:
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50443 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50443;
      inst->prev = 0B;
      D.50444 = inst->prev;
      inst->next = D.50444;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50445 = inst->sreg3;
      inst->sreg2 = D.50445;
      D.50446 = inst->sreg2;
      inst->sreg1 = D.50446;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = -1;
      inst->sreg1 = class_reg;
      array_class.487 = (long int) array_class;
      inst->data.op[1].const_val = array_class.487;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50448>; else goto <D.50449>;
      <D.50448>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50450>;
      <D.50449>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50450>:
    }
    <D.50442>:
  }
  goto <D.50451>;
  <D.50400>:
  if (context_used != 0) goto <D.50452>; else goto <D.50453>;
  <D.50452>:
  {
    struct MonoInst * vtable_ins;

    vtable_ins = emit_get_rgctx_klass (cfg, context_used, array_class, 2);
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50454 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50454;
      inst->prev = 0B;
      D.50455 = inst->prev;
      inst->next = D.50455;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50456 = inst->sreg3;
      inst->sreg2 = D.50456;
      D.50457 = inst->sreg2;
      inst->sreg1 = D.50457;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      D.50458 = vtable_ins->dreg;
      inst->sreg2 = D.50458;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50459>; else goto <D.50460>;
      <D.50459>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50461>;
      <D.50460>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50461>:
    }
  }
  goto <D.50462>;
  <D.50453>:
  D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.50410 = D.50409 & 274877906944;
  if (D.50410 != 0) goto <D.50463>; else goto <D.50464>;
  <D.50463>:
  {
    int vt_reg;
    struct MonoVTable * vtable;

    D.50465 = cfg->domain;
    vtable = mono_class_vtable (D.50465, array_class);
    if (vtable == 0B) goto <D.50466>; else goto <D.50467>;
    <D.50466>:
    return;
    <D.50467>:
    D.50468 = alloc_preg (cfg);
    vt_reg = (int) D.50468;
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50469 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50469;
      inst->prev = 0B;
      D.50470 = inst->prev;
      inst->next = D.50470;
      D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.50410 = D.50409 & 274877906944;
      if (D.50410 != 0) goto <D.50472>; else goto <D.50473>;
      <D.50472>:
      iftmp.488 = 734;
      goto <D.50474>;
      <D.50473>:
      iftmp.488 = 363;
      <D.50474>:
      inst->opcode = iftmp.488;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50475 = inst->sreg3;
      inst->sreg2 = D.50475;
      D.50476 = inst->sreg2;
      inst->sreg1 = D.50476;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.50410 = D.50409 & 274877906944;
      if (D.50410 != 0) goto <D.50477>; else goto <D.50478>;
      <D.50477>:
      {
        struct MonoInst * group;
        struct MonoInst * got_loc;

        got_loc = mono_get_got_var (cfg);
        D.50370 = cfg->mempool;
        group = mono_mempool_alloc (D.50370, 80);
        group->data.op[1].const_val = 0;
        D.50479 = group->data.op[1].const_val;
        group->data.op[0].const_val = D.50479;
        group->prev = 0B;
        D.50480 = group->prev;
        group->next = D.50480;
        group->opcode = 733;
        group->flags = 0;
        group->type = 0;
        group->dreg = -1;
        group->sreg3 = -1;
        D.50481 = group->sreg3;
        group->sreg2 = D.50481;
        D.50482 = group->sreg2;
        group->sreg1 = D.50482;
        D.50375 = cfg->ip;
        group->cil_code = D.50375;
        D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50410 = D.50409 & 274877906944;
        if (D.50410 != 0) goto <D.50484>; else goto <D.50485>;
        <D.50484>:
        iftmp.489 = vtable->klass;
        goto <D.50486>;
        <D.50485>:
        iftmp.489 = vtable;
        <D.50486>:
        group->data.op[0].src = iftmp.489;
        group->data.op[1].src = 14B;
        D.50487 = got_loc->dreg;
        inst->sreg1 = D.50487;
        inst->data.op[1].p = group;
      }
      goto <D.50488>;
      <D.50478>:
      D.50409 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.50410 = D.50409 & 274877906944;
      if (D.50410 != 0) goto <D.50490>; else goto <D.50491>;
      <D.50490>:
      iftmp.490 = vtable->klass;
      goto <D.50492>;
      <D.50491>:
      iftmp.490 = vtable;
      <D.50492>:
      inst->data.op[0].p = iftmp.490;
      inst->data.op[1].src = 14B;
      <D.50488>:
      inst->type = 3;
      D.50493 = alloc_dreg (cfg, 3);
      D.50494 = (int) D.50493;
      inst->dreg = D.50494;
      inst->dreg = vt_reg;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50495>; else goto <D.50496>;
      <D.50495>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50497>;
      <D.50496>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50497>:
    }
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50498 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50498;
      inst->prev = 0B;
      D.50499 = inst->prev;
      inst->next = D.50499;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50500 = inst->sreg3;
      inst->sreg2 = D.50500;
      D.50501 = inst->sreg2;
      inst->sreg1 = D.50501;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      inst->sreg2 = vt_reg;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50502>; else goto <D.50503>;
      <D.50502>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50504>;
      <D.50503>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50504>:
    }
  }
  goto <D.50505>;
  <D.50464>:
  {
    struct MonoVTable * vtable;

    D.50465 = cfg->domain;
    vtable = mono_class_vtable (D.50465, array_class);
    if (vtable == 0B) goto <D.50506>; else goto <D.50507>;
    <D.50506>:
    return;
    <D.50507>:
    {
      struct MonoInst * inst;

      D.50370 = cfg->mempool;
      inst = mono_mempool_alloc (D.50370, 80);
      inst->data.op[1].const_val = 0;
      D.50508 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50508;
      inst->prev = 0B;
      D.50509 = inst->prev;
      inst->next = D.50509;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50510 = inst->sreg3;
      inst->sreg2 = D.50510;
      D.50511 = inst->sreg2;
      inst->sreg1 = D.50511;
      D.50375 = cfg->ip;
      inst->cil_code = D.50375;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      vtable.491 = (long int) vtable;
      inst->data.op[1].const_val = vtable.491;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      if (D.50377 != 0B) goto <D.50513>; else goto <D.50514>;
      <D.50513>:
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      D.50377->next = inst;
      D.50376 = cfg->cbb;
      D.50377 = D.50376->last_ins;
      inst->prev = D.50377;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      goto <D.50515>;
      <D.50514>:
      D.50376 = cfg->cbb;
      D.50376 = cfg->cbb;
      D.50376->last_ins = inst;
      D.50377 = D.50376->last_ins;
      D.50376->code = D.50377;
      <D.50515>:
    }
  }
  <D.50505>:
  <D.50462>:
  <D.50451>:
  {
    struct MonoInst * inst;

    D.50370 = cfg->mempool;
    inst = mono_mempool_alloc (D.50370, 80);
    inst->data.op[1].const_val = 0;
    D.50516 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50516;
    inst->prev = 0B;
    D.50517 = inst->prev;
    inst->next = D.50517;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50518 = inst->sreg3;
    inst->sreg2 = D.50518;
    D.50519 = inst->sreg2;
    inst->sreg1 = D.50519;
    D.50375 = cfg->ip;
    inst->cil_code = D.50375;
    inst->data.op[1].p = "ArrayTypeMismatchException";
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    if (D.50377 != 0B) goto <D.50520>; else goto <D.50521>;
    <D.50520>:
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    D.50377->next = inst;
    D.50376 = cfg->cbb;
    D.50377 = D.50376->last_ins;
    inst->prev = D.50377;
    D.50376 = cfg->cbb;
    D.50376->last_ins = inst;
    goto <D.50522>;
    <D.50521>:
    D.50376 = cfg->cbb;
    D.50376 = cfg->cbb;
    D.50376->last_ins = inst;
    D.50377 = D.50376->last_ins;
    D.50376->code = D.50377;
    <D.50522>:
  }
  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.50524;
  int D.50528;
  unsigned int D.50529;
  unsigned int D.50533;
  struct MonoMemPool * D.50534;
  long int D.50535;
  struct MonoInst * D.50536;
  int D.50537;
  int D.50538;
  const unsigned char * D.50539;
  struct MonoBasicBlock * D.50540;
  struct MonoInst * D.50541;
  unsigned int D.50547;
  unsigned int D.50548;
  unsigned int D.50551;
  long unsigned int D.50554;
  long unsigned int D.50555;
  long int D.50558;
  struct MonoInst * D.50559;
  int D.50560;
  int D.50561;
  long int D.50565;
  struct MonoInst * D.50566;
  int D.50567;
  int D.50568;
  unsigned int D.50575;
  int D.50578;
  long int D.50583;
  struct MonoInst * D.50584;
  int D.50585;
  int D.50586;
  long int D.50590;
  struct MonoInst * D.50591;
  int D.50592;
  int D.50593;
  long int D.50598;
  struct MonoInst * D.50599;
  int D.50600;
  int D.50601;
  unsigned char D.50602;
  int D.50607;
  long int D.50612;
  struct MonoInst * D.50613;
  int D.50614;
  int D.50615;
  long int D.50619;
  struct MonoInst * D.50620;
  int D.50621;
  int D.50622;
  long int D.50627;
  struct MonoInst * D.50628;
  int D.50629;
  int D.50630;
  unsigned char D.50631;
  long int D.50635;
  struct MonoInst * D.50636;
  int D.50637;
  int D.50638;
  long int D.50642;
  struct MonoInst * D.50643;
  int D.50644;
  int D.50645;
  unsigned int D.50650;
  int D.50653;
  long int D.50658;
  struct MonoInst * D.50659;
  int D.50660;
  int D.50661;
  long int D.50665;
  struct MonoInst * D.50666;
  int D.50667;
  int D.50668;
  long int D.50673;
  struct MonoInst * D.50674;
  int D.50675;
  int D.50676;
  unsigned char D.50677;
  int D.50682;
  long int D.50687;
  struct MonoInst * D.50688;
  int D.50689;
  int D.50690;
  long int D.50694;
  struct MonoInst * D.50695;
  int D.50696;
  int D.50697;
  long int D.50702;
  struct MonoInst * D.50703;
  int D.50704;
  int D.50705;
  unsigned char D.50706;
  long int D.50710;
  struct MonoInst * D.50711;
  int D.50712;
  int D.50713;
  long int D.50717;
  struct MonoInst * D.50718;
  int D.50719;
  int D.50720;
  long int D.50725;
  struct MonoInst * D.50726;
  int D.50727;
  int D.50728;
  unsigned char D.50729;
  unsigned char D.50730;
  unsigned int D.50734;
  unsigned int D.50735;
  unsigned int D.50736;
  struct MonoGenericSharingContext * D.50739;
  _Bool D.50740;
  long int D.50741;
  long int D.50742;
  _Bool D.50745;
  long int D.50746;
  long int D.50747;
  struct MonoType * D.50750;
  long int D.50751;
  struct MonoInst * D.50752;
  int D.50753;
  int D.50754;
  int D.50755;
  long int D.50760;
  struct MonoInst * D.50761;
  int D.50762;
  int D.50763;
  long int D.50764;
  long int D.50768;
  struct MonoInst * D.50769;
  int D.50770;
  int D.50771;
  long int D.50775;
  struct MonoInst * D.50776;
  int D.50777;
  int D.50778;
  struct MonoClass * D.50779;
  struct MonoInst * D.50783;
  struct MonoInst * ins;
  guint32 size;
  int mult_reg;
  int add_reg;
  int array_reg;
  int index_reg;
  int index2_reg;
  int context_used;

  D.50524 = mini_is_gsharedvt_variable_klass (cfg, klass);
  if (D.50524 != 0) goto <D.50525>; else goto <D.50526>;
  <D.50525>:
  size = 4294967295;
  goto <D.50527>;
  <D.50526>:
  mono_class_init (klass);
  D.50528 = mono_class_array_element_size (klass);
  size = (guint32) D.50528;
  <D.50527>:
  D.50529 = alloc_preg (cfg);
  mult_reg = (int) D.50529;
  array_reg = arr->dreg;
  index_reg = index->dreg;
  if (0 != 0) goto <D.50530>; else goto <D.50531>;
  <D.50530>:
  index2_reg = index_reg;
  goto <D.50532>;
  <D.50531>:
  D.50533 = alloc_preg (cfg);
  index2_reg = (int) D.50533;
  {
    struct MonoInst * inst;

    D.50534 = cfg->mempool;
    inst = mono_mempool_alloc (D.50534, 80);
    inst->data.op[1].const_val = 0;
    D.50535 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50535;
    inst->prev = 0B;
    D.50536 = inst->prev;
    inst->next = D.50536;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50537 = inst->sreg3;
    inst->sreg2 = D.50537;
    D.50538 = inst->sreg2;
    inst->sreg1 = D.50538;
    D.50539 = cfg->ip;
    inst->cil_code = D.50539;
    inst->dreg = index2_reg;
    inst->sreg1 = index_reg;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50542>; else goto <D.50543>;
    <D.50542>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = inst;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    inst->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    goto <D.50544>;
    <D.50543>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50544>:
  }
  <D.50532>:
  if (bcheck != 0) goto <D.50545>; else goto <D.50546>;
  <D.50545>:
  D.50547 = cfg->opt;
  D.50548 = D.50547 & 134217728;
  if (D.50548 == 0) goto <D.50549>; else goto <D.50550>;
  <D.50549>:
  D.50547 = cfg->opt;
  D.50551 = D.50547 & 262144;
  if (D.50551 == 0) goto <D.50552>; else goto <D.50553>;
  <D.50552>:
  D.50554 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.50555 = D.50554 & 64;
  if (D.50555 != 0) goto <D.50556>; else goto <D.50557>;
  <D.50556>:
  {
    struct MonoInst * inst;

    D.50534 = cfg->mempool;
    inst = mono_mempool_alloc (D.50534, 80);
    inst->data.op[1].const_val = 0;
    D.50558 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50558;
    inst->prev = 0B;
    D.50559 = inst->prev;
    inst->next = D.50559;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50560 = inst->sreg3;
    inst->sreg2 = D.50560;
    D.50561 = inst->sreg2;
    inst->sreg1 = D.50561;
    D.50539 = cfg->ip;
    inst->cil_code = D.50539;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50562>; else goto <D.50563>;
    <D.50562>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = inst;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    inst->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    goto <D.50564>;
    <D.50563>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50564>:
  }
  {
    struct MonoInst * inst;

    D.50534 = cfg->mempool;
    inst = mono_mempool_alloc (D.50534, 80);
    inst->data.op[1].const_val = 0;
    D.50565 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50565;
    inst->prev = 0B;
    D.50566 = inst->prev;
    inst->next = D.50566;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50567 = inst->sreg3;
    inst->sreg2 = D.50567;
    D.50568 = inst->sreg2;
    inst->sreg1 = D.50568;
    D.50539 = cfg->ip;
    inst->cil_code = D.50539;
    inst->data.op[1].p = "NullReferenceException";
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50569>; else goto <D.50570>;
    <D.50569>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = inst;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    inst->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    goto <D.50571>;
    <D.50570>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50571>:
  }
  goto <D.50572>;
  <D.50557>:
  <D.50572>:
  if (0 != 0) goto <D.50573>; else goto <D.50574>;
  <D.50573>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.50578 = __ins_flags & 32;
      if (D.50578 != 0) goto <D.50579>; else goto <D.50580>;
      <D.50579>:
      D.50554 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50555 = D.50554 & 64;
      if (D.50555 != 0) goto <D.50581>; else goto <D.50582>;
      <D.50581>:
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50583 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50583;
        inst->prev = 0B;
        D.50584 = inst->prev;
        inst->next = D.50584;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50585 = inst->sreg3;
        inst->sreg2 = D.50585;
        D.50586 = inst->sreg2;
        inst->sreg1 = D.50586;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50587>; else goto <D.50588>;
        <D.50587>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50589>;
        <D.50588>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50589>:
      }
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50590 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50590;
        inst->prev = 0B;
        D.50591 = inst->prev;
        inst->next = D.50591;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50592 = inst->sreg3;
        inst->sreg2 = D.50592;
        D.50593 = inst->sreg2;
        inst->sreg1 = D.50593;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->data.op[1].p = "NullReferenceException";
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50594>; else goto <D.50595>;
        <D.50594>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50596>;
        <D.50595>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50596>:
      }
      goto <D.50597>;
      <D.50582>:
      <D.50597>:
      <D.50580>:
      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50598 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50598;
      inst->prev = 0B;
      D.50599 = inst->prev;
      inst->next = D.50599;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50600 = inst->sreg3;
      inst->sreg2 = D.50600;
      D.50601 = inst->sreg2;
      inst->sreg1 = D.50601;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.50602 = (unsigned char) __ins_flags;
      inst->flags = D.50602;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50603>; else goto <D.50604>;
      <D.50603>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50605>;
      <D.50604>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50605>:
    }
    goto <D.50606>;
    <D.50577>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.50607 = __ins_flags & 32;
      if (D.50607 != 0) goto <D.50608>; else goto <D.50609>;
      <D.50608>:
      D.50554 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50555 = D.50554 & 64;
      if (D.50555 != 0) goto <D.50610>; else goto <D.50611>;
      <D.50610>:
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50612 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50612;
        inst->prev = 0B;
        D.50613 = inst->prev;
        inst->next = D.50613;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50614 = inst->sreg3;
        inst->sreg2 = D.50614;
        D.50615 = inst->sreg2;
        inst->sreg1 = D.50615;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50616>; else goto <D.50617>;
        <D.50616>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50618>;
        <D.50617>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50618>:
      }
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50619 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50619;
        inst->prev = 0B;
        D.50620 = inst->prev;
        inst->next = D.50620;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50621 = inst->sreg3;
        inst->sreg2 = D.50621;
        D.50622 = inst->sreg2;
        inst->sreg1 = D.50622;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->data.op[1].p = "NullReferenceException";
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50623>; else goto <D.50624>;
        <D.50623>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50625>;
        <D.50624>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50625>:
      }
      goto <D.50626>;
      <D.50611>:
      <D.50626>:
      <D.50609>:
      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50627 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50627;
      inst->prev = 0B;
      D.50628 = inst->prev;
      inst->next = D.50628;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50629 = inst->sreg3;
      inst->sreg2 = D.50629;
      D.50630 = inst->sreg2;
      inst->sreg1 = D.50630;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.50631 = (unsigned char) __ins_flags;
      inst->flags = D.50631;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50632>; else goto <D.50633>;
      <D.50632>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50634>;
      <D.50633>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50634>:
    }
    <D.50606>:
    {
      struct MonoInst * inst;

      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50635 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50635;
      inst->prev = 0B;
      D.50636 = inst->prev;
      inst->next = D.50636;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50637 = inst->sreg3;
      inst->sreg2 = D.50637;
      D.50638 = inst->sreg2;
      inst->sreg1 = D.50638;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50639>; else goto <D.50640>;
      <D.50639>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50641>;
      <D.50640>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50641>:
    }
    {
      struct MonoInst * inst;

      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50642 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50642;
      inst->prev = 0B;
      D.50643 = inst->prev;
      inst->next = D.50643;
      inst->opcode = 459;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50644 = inst->sreg3;
      inst->sreg2 = D.50644;
      D.50645 = inst->sreg2;
      inst->sreg1 = D.50645;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50646>; else goto <D.50647>;
      <D.50646>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50648>;
      <D.50647>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50648>:
    }
  }
  goto <D.50649>;
  <D.50574>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.50653 = __ins_flags & 32;
      if (D.50653 != 0) goto <D.50654>; else goto <D.50655>;
      <D.50654>:
      D.50554 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50555 = D.50554 & 64;
      if (D.50555 != 0) goto <D.50656>; else goto <D.50657>;
      <D.50656>:
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50658 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50658;
        inst->prev = 0B;
        D.50659 = inst->prev;
        inst->next = D.50659;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50660 = inst->sreg3;
        inst->sreg2 = D.50660;
        D.50661 = inst->sreg2;
        inst->sreg1 = D.50661;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50662>; else goto <D.50663>;
        <D.50662>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50664>;
        <D.50663>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50664>:
      }
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50665 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50665;
        inst->prev = 0B;
        D.50666 = inst->prev;
        inst->next = D.50666;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50667 = inst->sreg3;
        inst->sreg2 = D.50667;
        D.50668 = inst->sreg2;
        inst->sreg1 = D.50668;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->data.op[1].p = "NullReferenceException";
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50669>; else goto <D.50670>;
        <D.50669>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50671>;
        <D.50670>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50671>:
      }
      goto <D.50672>;
      <D.50657>:
      <D.50672>:
      <D.50655>:
      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50673 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50673;
      inst->prev = 0B;
      D.50674 = inst->prev;
      inst->next = D.50674;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50675 = inst->sreg3;
      inst->sreg2 = D.50675;
      D.50676 = inst->sreg2;
      inst->sreg1 = D.50676;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.50677 = (unsigned char) __ins_flags;
      inst->flags = D.50677;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50678>; else goto <D.50679>;
      <D.50678>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50680>;
      <D.50679>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50680>:
    }
    goto <D.50681>;
    <D.50652>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.50682 = __ins_flags & 32;
      if (D.50682 != 0) goto <D.50683>; else goto <D.50684>;
      <D.50683>:
      D.50554 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50555 = D.50554 & 64;
      if (D.50555 != 0) goto <D.50685>; else goto <D.50686>;
      <D.50685>:
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50687 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50687;
        inst->prev = 0B;
        D.50688 = inst->prev;
        inst->next = D.50688;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50689 = inst->sreg3;
        inst->sreg2 = D.50689;
        D.50690 = inst->sreg2;
        inst->sreg1 = D.50690;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50691>; else goto <D.50692>;
        <D.50691>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50693>;
        <D.50692>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50693>:
      }
      {
        struct MonoInst * inst;

        D.50534 = cfg->mempool;
        inst = mono_mempool_alloc (D.50534, 80);
        inst->data.op[1].const_val = 0;
        D.50694 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50694;
        inst->prev = 0B;
        D.50695 = inst->prev;
        inst->next = D.50695;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50696 = inst->sreg3;
        inst->sreg2 = D.50696;
        D.50697 = inst->sreg2;
        inst->sreg1 = D.50697;
        D.50539 = cfg->ip;
        inst->cil_code = D.50539;
        inst->data.op[1].p = "NullReferenceException";
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        if (D.50541 != 0B) goto <D.50698>; else goto <D.50699>;
        <D.50698>:
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        D.50541->next = inst;
        D.50540 = cfg->cbb;
        D.50541 = D.50540->last_ins;
        inst->prev = D.50541;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        goto <D.50700>;
        <D.50699>:
        D.50540 = cfg->cbb;
        D.50540 = cfg->cbb;
        D.50540->last_ins = inst;
        D.50541 = D.50540->last_ins;
        D.50540->code = D.50541;
        <D.50700>:
      }
      goto <D.50701>;
      <D.50686>:
      <D.50701>:
      <D.50684>:
      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50702 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50702;
      inst->prev = 0B;
      D.50703 = inst->prev;
      inst->next = D.50703;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50704 = inst->sreg3;
      inst->sreg2 = D.50704;
      D.50705 = inst->sreg2;
      inst->sreg1 = D.50705;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.50706 = (unsigned char) __ins_flags;
      inst->flags = D.50706;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50707>; else goto <D.50708>;
      <D.50707>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50709>;
      <D.50708>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50709>:
    }
    <D.50681>:
    {
      struct MonoInst * inst;

      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50710 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50710;
      inst->prev = 0B;
      D.50711 = inst->prev;
      inst->next = D.50711;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50712 = inst->sreg3;
      inst->sreg2 = D.50712;
      D.50713 = inst->sreg2;
      inst->sreg1 = D.50713;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50714>; else goto <D.50715>;
      <D.50714>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50716>;
      <D.50715>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50716>:
    }
    {
      struct MonoInst * inst;

      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50717 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50717;
      inst->prev = 0B;
      D.50718 = inst->prev;
      inst->next = D.50718;
      inst->opcode = 459;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50719 = inst->sreg3;
      inst->sreg2 = D.50719;
      D.50720 = inst->sreg2;
      inst->sreg1 = D.50720;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50721>; else goto <D.50722>;
      <D.50721>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50723>;
      <D.50722>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50723>:
    }
  }
  <D.50649>:
  goto <D.50724>;
  <D.50553>:
  {
    struct MonoInst * ins;

    D.50534 = cfg->mempool;
    ins = mono_mempool_alloc (D.50534, 80);
    ins->data.op[1].const_val = 0;
    D.50725 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.50725;
    ins->prev = 0B;
    D.50726 = ins->prev;
    ins->next = D.50726;
    ins->opcode = 784;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.50727 = ins->sreg3;
    ins->sreg2 = D.50727;
    D.50728 = ins->sreg2;
    ins->sreg1 = D.50728;
    D.50539 = cfg->ip;
    ins->cil_code = D.50539;
    ins->sreg1 = array_reg;
    ins->sreg2 = index2_reg;
    ins->data.op[1].const_val = 24;
    D.50729 = ins->flags;
    D.50730 = D.50729 | 32;
    ins->flags = D.50730;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50731>; else goto <D.50732>;
    <D.50731>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = ins;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    ins->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = ins;
    goto <D.50733>;
    <D.50732>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = ins;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50733>:
    D.50734 = cfg->flags;
    D.50735 = D.50734 | 256;
    cfg->flags = D.50735;
    D.50540 = cfg->cbb;
    D.50540->has_array_access = 1;
  }
  <D.50724>:
  <D.50550>:
  <D.50546>:
  D.50736 = alloc_ireg_mp (cfg);
  add_reg = (int) D.50736;
  if (size == 4294967295) goto <D.50737>; else goto <D.50738>;
  <D.50737>:
  {
    struct MonoInst * rgctx_ins;

    D.50739 = cfg->generic_sharing_context;
    D.50740 = D.50739 == 0B;
    D.50741 = (long int) D.50740;
    D.50742 = __builtin_expect (D.50741, 0);
    if (D.50742 != 0) goto <D.50743>; else goto <D.50744>;
    <D.50743>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4718, "cfg->generic_sharing_context");
    <D.50744>:
    context_used = mini_class_check_context_used (cfg, klass);
    D.50745 = context_used == 0;
    D.50746 = (long int) D.50745;
    D.50747 = __builtin_expect (D.50746, 0);
    if (D.50747 != 0) goto <D.50748>; else goto <D.50749>;
    <D.50748>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4720, "context_used");
    <D.50749>:
    D.50750 = &klass->byval_arg;
    rgctx_ins = emit_get_gsharedvt_info (cfg, D.50750, 13);
    {
      struct MonoInst * inst;

      D.50534 = cfg->mempool;
      inst = mono_mempool_alloc (D.50534, 80);
      inst->data.op[1].const_val = 0;
      D.50751 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.50751;
      inst->prev = 0B;
      D.50752 = inst->prev;
      inst->next = D.50752;
      inst->opcode = 567;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.50753 = inst->sreg3;
      inst->sreg2 = D.50753;
      D.50754 = inst->sreg2;
      inst->sreg1 = D.50754;
      D.50539 = cfg->ip;
      inst->cil_code = D.50539;
      inst->dreg = mult_reg;
      inst->sreg1 = index2_reg;
      D.50755 = rgctx_ins->dreg;
      inst->sreg2 = D.50755;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      if (D.50541 != 0B) goto <D.50756>; else goto <D.50757>;
      <D.50756>:
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      D.50541->next = inst;
      D.50540 = cfg->cbb;
      D.50541 = D.50540->last_ins;
      inst->prev = D.50541;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      goto <D.50758>;
      <D.50757>:
      D.50540 = cfg->cbb;
      D.50540 = cfg->cbb;
      D.50540->last_ins = inst;
      D.50541 = D.50540->last_ins;
      D.50540->code = D.50541;
      <D.50758>:
    }
  }
  goto <D.50759>;
  <D.50738>:
  {
    struct MonoInst * inst;

    D.50534 = cfg->mempool;
    inst = mono_mempool_alloc (D.50534, 80);
    inst->data.op[1].const_val = 0;
    D.50760 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50760;
    inst->prev = 0B;
    D.50761 = inst->prev;
    inst->next = D.50761;
    inst->opcode = 431;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50762 = inst->sreg3;
    inst->sreg2 = D.50762;
    D.50763 = inst->sreg2;
    inst->sreg1 = D.50763;
    D.50539 = cfg->ip;
    inst->cil_code = D.50539;
    inst->dreg = mult_reg;
    inst->sreg1 = index2_reg;
    D.50764 = (long int) size;
    inst->data.op[1].const_val = D.50764;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50765>; else goto <D.50766>;
    <D.50765>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = inst;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    inst->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    goto <D.50767>;
    <D.50766>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50767>:
  }
  <D.50759>:
  {
    struct MonoInst * inst;

    D.50534 = cfg->mempool;
    inst = mono_mempool_alloc (D.50534, 80);
    inst->data.op[1].const_val = 0;
    D.50768 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.50768;
    inst->prev = 0B;
    D.50769 = inst->prev;
    inst->next = D.50769;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.50770 = inst->sreg3;
    inst->sreg2 = D.50770;
    D.50771 = inst->sreg2;
    inst->sreg1 = D.50771;
    D.50539 = cfg->ip;
    inst->cil_code = D.50539;
    inst->dreg = add_reg;
    inst->sreg1 = array_reg;
    inst->sreg2 = mult_reg;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    if (D.50541 != 0B) goto <D.50772>; else goto <D.50773>;
    <D.50772>:
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    D.50541->next = inst;
    D.50540 = cfg->cbb;
    D.50541 = D.50540->last_ins;
    inst->prev = D.50541;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    goto <D.50774>;
    <D.50773>:
    D.50540 = cfg->cbb;
    D.50540 = cfg->cbb;
    D.50540->last_ins = inst;
    D.50541 = D.50540->last_ins;
    D.50540->code = D.50541;
    <D.50774>:
  }
  D.50534 = cfg->mempool;
  ins = mono_mempool_alloc (D.50534, 80);
  ins->data.op[1].const_val = 0;
  D.50775 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.50775;
  ins->prev = 0B;
  D.50776 = ins->prev;
  ins->next = D.50776;
  ins->opcode = 538;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.50777 = ins->sreg3;
  ins->sreg2 = D.50777;
  D.50778 = ins->sreg2;
  ins->sreg1 = D.50778;
  D.50539 = cfg->ip;
  ins->cil_code = D.50539;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 32;
  D.50779 = mono_class_get_element_class (klass);
  ins->klass = D.50779;
  ins->type = 5;
  D.50540 = cfg->cbb;
  D.50541 = D.50540->last_ins;
  if (D.50541 != 0B) goto <D.50780>; else goto <D.50781>;
  <D.50780>:
  D.50540 = cfg->cbb;
  D.50541 = D.50540->last_ins;
  D.50541->next = ins;
  D.50540 = cfg->cbb;
  D.50541 = D.50540->last_ins;
  ins->prev = D.50541;
  D.50540 = cfg->cbb;
  D.50540->last_ins = ins;
  goto <D.50782>;
  <D.50781>:
  D.50540 = cfg->cbb;
  D.50540 = cfg->cbb;
  D.50540->last_ins = ins;
  D.50541 = D.50540->last_ins;
  D.50540->code = D.50541;
  <D.50782>:
  D.50783 = ins;
  return D.50783;
}


array_access_to_klass (int opcode)
{
  struct MonoClass * D.50785;

  switch (opcode) <default: <D.25261>, case 144: <D.25246>, case 145: <D.25242>, case 146: <D.25248>, case 147: <D.25243>, case 148: <D.25250>, case 149: <D.25252>, case 150: <D.25253>, case 151: <D.25244>, case 152: <D.25255>, case 153: <D.25257>, case 154: <D.25259>, case 155: <D.25245>, case 156: <D.25247>, case 157: <D.25249>, case 158: <D.25251>, case 159: <D.25254>, case 160: <D.25256>, case 161: <D.25258>, case 162: <D.25260>>
  <D.25242>:
  D.50785 = mono_defaults.byte_class;
  return D.50785;
  <D.25243>:
  D.50785 = mono_defaults.uint16_class;
  return D.50785;
  <D.25244>:
  <D.25245>:
  D.50785 = mono_defaults.int_class;
  return D.50785;
  <D.25246>:
  <D.25247>:
  D.50785 = mono_defaults.sbyte_class;
  return D.50785;
  <D.25248>:
  <D.25249>:
  D.50785 = mono_defaults.int16_class;
  return D.50785;
  <D.25250>:
  <D.25251>:
  D.50785 = mono_defaults.int32_class;
  return D.50785;
  <D.25252>:
  D.50785 = mono_defaults.uint32_class;
  return D.50785;
  <D.25253>:
  <D.25254>:
  D.50785 = mono_defaults.int64_class;
  return D.50785;
  <D.25255>:
  <D.25256>:
  D.50785 = mono_defaults.single_class;
  return D.50785;
  <D.25257>:
  <D.25258>:
  D.50785 = mono_defaults.double_class;
  return D.50785;
  <D.25259>:
  <D.25260>:
  D.50785 = mono_defaults.object_class;
  return D.50785;
  <D.25261>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 1271);
  D.50785 = 0B;
  return D.50785;
}


emit_array_store (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * sp, gboolean safety_checks)
{
  int D.50790;
  struct MonoInst * * D.50792;
  struct MonoInst * D.50793;
  short unsigned int D.50794;
  void * D.50796;
  struct MonoClass * obj_array.494;
  struct MonoClass * tmp_klass.492;
  struct MonoClass * D.50800;
  struct MonoClass * tmp_klass.493;
  _Bool D.50802;
  long int D.50803;
  long int D.50804;
  short int D.50807;
  _Bool D.50810;
  long int D.50811;
  long int D.50812;
  struct MonoInst * D.50815;
  unsigned char D.50816;
  struct MonoInst * D.50819;
  unsigned char D.50820;
  struct MonoInst * D.50823;
  struct MonoInst * D.50824;
  int D.50825;
  struct MonoInst * * D.50828;
  struct MonoInst * D.50829;
  struct MonoMemPool * D.50830;
  long int D.50831;
  struct MonoInst * D.50832;
  struct MonoType * D.50833;
  unsigned int D.50834;
  short unsigned int D.50835;
  int D.50836;
  int D.50837;
  const unsigned char * D.50838;
  int D.50839;
  int D.50840;
  struct MonoClass * D.50841;
  struct MonoBasicBlock * D.50842;
  struct MonoInst * D.50843;
  short unsigned int D.50848;
  int D.50851;
  unsigned int D.50852;
  long int D.50853;
  unsigned int D.50854;
  unsigned int D.50855;
  unsigned int D.50856;
  unsigned int D.50859;
  unsigned int D.50860;
  unsigned int D.50863;
  long unsigned int D.50866;
  long unsigned int D.50867;
  long int D.50870;
  struct MonoInst * D.50871;
  int D.50872;
  int D.50873;
  long int D.50877;
  struct MonoInst * D.50878;
  int D.50879;
  int D.50880;
  unsigned int D.50887;
  int D.50890;
  long int D.50895;
  struct MonoInst * D.50896;
  int D.50897;
  int D.50898;
  long int D.50902;
  struct MonoInst * D.50903;
  int D.50904;
  int D.50905;
  long int D.50910;
  struct MonoInst * D.50911;
  int D.50912;
  int D.50913;
  unsigned char D.50914;
  int D.50919;
  long int D.50924;
  struct MonoInst * D.50925;
  int D.50926;
  int D.50927;
  long int D.50931;
  struct MonoInst * D.50932;
  int D.50933;
  int D.50934;
  long int D.50939;
  struct MonoInst * D.50940;
  int D.50941;
  int D.50942;
  unsigned char D.50943;
  long int D.50947;
  struct MonoInst * D.50948;
  int D.50949;
  int D.50950;
  long int D.50954;
  struct MonoInst * D.50955;
  int D.50956;
  int D.50957;
  unsigned int D.50962;
  int D.50965;
  long int D.50970;
  struct MonoInst * D.50971;
  int D.50972;
  int D.50973;
  long int D.50977;
  struct MonoInst * D.50978;
  int D.50979;
  int D.50980;
  long int D.50985;
  struct MonoInst * D.50986;
  int D.50987;
  int D.50988;
  unsigned char D.50989;
  int D.50994;
  long int D.50999;
  struct MonoInst * D.51000;
  int D.51001;
  int D.51002;
  long int D.51006;
  struct MonoInst * D.51007;
  int D.51008;
  int D.51009;
  long int D.51014;
  struct MonoInst * D.51015;
  int D.51016;
  int D.51017;
  unsigned char D.51018;
  long int D.51022;
  struct MonoInst * D.51023;
  int D.51024;
  int D.51025;
  long int D.51029;
  struct MonoInst * D.51030;
  int D.51031;
  int D.51032;
  long int D.51037;
  struct MonoInst * D.51038;
  int D.51039;
  int D.51040;
  unsigned char D.51041;
  unsigned char D.51042;
  unsigned int D.51046;
  unsigned int D.51047;
  unsigned int D.51048;
  short unsigned int D.51049;
  long int D.51050;
  struct MonoClass * D.51051;
  unsigned int D.51056;
  short unsigned int D.51057;
  int D.51058;
  struct MonoClass * D.51059;
  int D.51063;

  if (safety_checks != 0) goto <D.50789>; else goto <D.50787>;
  <D.50789>:
  D.50790 = generic_class_is_reference_type (cfg, klass);
  if (D.50790 != 0) goto <D.50791>; else goto <D.50787>;
  <D.50791>:
  D.50792 = sp + 16;
  D.50793 = *D.50792;
  D.50794 = D.50793->opcode;
  if (D.50794 != 363) goto <D.50788>; else goto <D.50795>;
  <D.50795>:
  D.50792 = sp + 16;
  D.50793 = *D.50792;
  D.50796 = D.50793->data.op[0].p;
  if (D.50796 != 0B) goto <D.50788>; else goto <D.50787>;
  <D.50788>:
  {
    struct MonoClass * obj_array;
    struct MonoMethod * helper;
    struct MonoInst * iargs[3];

    try
      {
        {
          static struct MonoClass * tmp_klass;

          {
            tmp_klass.492 = tmp_klass;
            if (tmp_klass.492 == 0B) goto <D.50798>; else goto <D.50799>;
            <D.50798>:
            D.50800 = mono_defaults.object_class;
            tmp_klass.493 = mono_array_class_get (D.50800, 1);
            tmp_klass = tmp_klass.493;
            tmp_klass.492 = tmp_klass;
            D.50802 = tmp_klass.492 == 0B;
            D.50803 = (long int) D.50802;
            D.50804 = __builtin_expect (D.50803, 0);
            if (D.50804 != 0) goto <D.50805>; else goto <D.50806>;
            <D.50805>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4919, "tmp_klass");
            <D.50806>:
            <D.50799>:
          }
          obj_array.494 = tmp_klass;
        }
        obj_array = obj_array.494;
        helper = mono_marshal_get_virtual_stelemref (obj_array);
        D.50807 = helper->slot;
        if (D.50807 == 0) goto <D.50808>; else goto <D.50809>;
        <D.50808>:
        mono_class_setup_vtable (obj_array);
        <D.50809>:
        D.50807 = helper->slot;
        D.50810 = D.50807 == 0;
        D.50811 = (long int) D.50810;
        D.50812 = __builtin_expect (D.50811, 0);
        if (D.50812 != 0) goto <D.50813>; else goto <D.50814>;
        <D.50813>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4925, "helper->slot");
        <D.50814>:
        D.50815 = *sp;
        D.50816 = D.50815->type;
        if (D.50816 != 6) goto <D.50817>; else goto <D.50818>;
        <D.50817>:
        D.50819 = 0B;
        return D.50819;
        <D.50818>:
        D.50792 = sp + 16;
        D.50793 = *D.50792;
        D.50820 = D.50793->type;
        if (D.50820 != 6) goto <D.50821>; else goto <D.50822>;
        <D.50821>:
        D.50819 = 0B;
        return D.50819;
        <D.50822>:
        D.50823 = MEM[(struct MonoInst * *)sp + 16B];
        iargs[2] = D.50823;
        D.50824 = MEM[(struct MonoInst * *)sp + 8B];
        iargs[1] = D.50824;
        D.50815 = *sp;
        iargs[0] = D.50815;
        D.50815 = *sp;
        D.50819 = mono_emit_method_call (cfg, helper, &iargs, D.50815);
        return D.50819;
      }
    finally
      {
        iargs = {CLOBBER};
      }
  }
  <D.50787>:
  {
    struct MonoInst * ins;

    D.50825 = mini_is_gsharedvt_variable_klass (cfg, klass);
    if (D.50825 != 0) goto <D.50826>; else goto <D.50827>;
    <D.50826>:
    {
      struct MonoInst * addr;

      D.50815 = *sp;
      D.50828 = sp + 8;
      D.50829 = *D.50828;
      addr = mini_emit_ldelema_1_ins (cfg, klass, D.50815, D.50829, 1);
      D.50830 = cfg->mempool;
      ins = mono_mempool_alloc (D.50830, 80);
      ins->data.op[1].const_val = 0;
      D.50831 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.50831;
      ins->prev = 0B;
      D.50832 = ins->prev;
      ins->next = D.50832;
      D.50833 = &klass->byval_arg;
      D.50834 = mono_type_to_store_membase (cfg, D.50833);
      D.50835 = (short unsigned int) D.50834;
      ins->opcode = D.50835;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.50836 = ins->sreg3;
      ins->sreg2 = D.50836;
      D.50837 = ins->sreg2;
      ins->sreg1 = D.50837;
      D.50838 = cfg->ip;
      ins->cil_code = D.50838;
      D.50792 = sp + 16;
      D.50793 = *D.50792;
      D.50839 = D.50793->dreg;
      ins->sreg1 = D.50839;
      D.50840 = addr->dreg;
      ins->dreg = D.50840;
      ins->data.op[0].const_val = 0;
      D.50833 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.50833, ins);
      D.50833 = &klass->byval_arg;
      D.50841 = mono_class_from_mono_type (D.50833);
      ins->klass = D.50841;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      if (D.50843 != 0B) goto <D.50844>; else goto <D.50845>;
      <D.50844>:
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      D.50843->next = ins;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      ins->prev = D.50843;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      goto <D.50846>;
      <D.50845>:
      D.50842 = cfg->cbb;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      D.50843 = D.50842->last_ins;
      D.50842->code = D.50843;
      <D.50846>:
      ins->opcode = 387;
    }
    goto <D.50847>;
    <D.50827>:
    D.50828 = sp + 8;
    D.50829 = *D.50828;
    D.50848 = D.50829->opcode;
    if (D.50848 == 362) goto <D.50849>; else goto <D.50850>;
    <D.50849>:
    {
      int array_reg;
      int index_reg;
      int offset;

      D.50815 = *sp;
      array_reg = D.50815->dreg;
      D.50828 = sp + 8;
      D.50829 = *D.50828;
      index_reg = D.50829->dreg;
      D.50851 = mono_class_array_element_size (klass);
      D.50852 = (unsigned int) D.50851;
      D.50828 = sp + 8;
      D.50829 = *D.50828;
      D.50853 = D.50829->data.op[0].const_val;
      D.50854 = (unsigned int) D.50853;
      D.50855 = D.50852 * D.50854;
      D.50856 = D.50855 + 32;
      offset = (int) D.50856;
      if (safety_checks != 0) goto <D.50857>; else goto <D.50858>;
      <D.50857>:
      D.50859 = cfg->opt;
      D.50860 = D.50859 & 134217728;
      if (D.50860 == 0) goto <D.50861>; else goto <D.50862>;
      <D.50861>:
      D.50859 = cfg->opt;
      D.50863 = D.50859 & 262144;
      if (D.50863 == 0) goto <D.50864>; else goto <D.50865>;
      <D.50864>:
      D.50866 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50867 = D.50866 & 64;
      if (D.50867 != 0) goto <D.50868>; else goto <D.50869>;
      <D.50868>:
      {
        struct MonoInst * inst;

        D.50830 = cfg->mempool;
        inst = mono_mempool_alloc (D.50830, 80);
        inst->data.op[1].const_val = 0;
        D.50870 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50870;
        inst->prev = 0B;
        D.50871 = inst->prev;
        inst->next = D.50871;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50872 = inst->sreg3;
        inst->sreg2 = D.50872;
        D.50873 = inst->sreg2;
        inst->sreg1 = D.50873;
        D.50838 = cfg->ip;
        inst->cil_code = D.50838;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        if (D.50843 != 0B) goto <D.50874>; else goto <D.50875>;
        <D.50874>:
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        D.50843->next = inst;
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        inst->prev = D.50843;
        D.50842 = cfg->cbb;
        D.50842->last_ins = inst;
        goto <D.50876>;
        <D.50875>:
        D.50842 = cfg->cbb;
        D.50842 = cfg->cbb;
        D.50842->last_ins = inst;
        D.50843 = D.50842->last_ins;
        D.50842->code = D.50843;
        <D.50876>:
      }
      {
        struct MonoInst * inst;

        D.50830 = cfg->mempool;
        inst = mono_mempool_alloc (D.50830, 80);
        inst->data.op[1].const_val = 0;
        D.50877 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.50877;
        inst->prev = 0B;
        D.50878 = inst->prev;
        inst->next = D.50878;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.50879 = inst->sreg3;
        inst->sreg2 = D.50879;
        D.50880 = inst->sreg2;
        inst->sreg1 = D.50880;
        D.50838 = cfg->ip;
        inst->cil_code = D.50838;
        inst->data.op[1].p = "NullReferenceException";
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        if (D.50843 != 0B) goto <D.50881>; else goto <D.50882>;
        <D.50881>:
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        D.50843->next = inst;
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        inst->prev = D.50843;
        D.50842 = cfg->cbb;
        D.50842->last_ins = inst;
        goto <D.50883>;
        <D.50882>:
        D.50842 = cfg->cbb;
        D.50842 = cfg->cbb;
        D.50842->last_ins = inst;
        D.50843 = D.50842->last_ins;
        D.50842->code = D.50843;
        <D.50883>:
      }
      goto <D.50884>;
      <D.50869>:
      <D.50884>:
      if (0 != 0) goto <D.50885>; else goto <D.50886>;
      <D.50885>:
      {
        int _length_reg;

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

          __ins_flags = 32;
          D.50890 = __ins_flags & 32;
          if (D.50890 != 0) goto <D.50891>; else goto <D.50892>;
          <D.50891>:
          D.50866 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.50867 = D.50866 & 64;
          if (D.50867 != 0) goto <D.50893>; else goto <D.50894>;
          <D.50893>:
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50895 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50895;
            inst->prev = 0B;
            D.50896 = inst->prev;
            inst->next = D.50896;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50897 = inst->sreg3;
            inst->sreg2 = D.50897;
            D.50898 = inst->sreg2;
            inst->sreg1 = D.50898;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50899>; else goto <D.50900>;
            <D.50899>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50901>;
            <D.50900>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50901>:
          }
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50902 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50902;
            inst->prev = 0B;
            D.50903 = inst->prev;
            inst->next = D.50903;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50904 = inst->sreg3;
            inst->sreg2 = D.50904;
            D.50905 = inst->sreg2;
            inst->sreg1 = D.50905;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->data.op[1].p = "NullReferenceException";
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50906>; else goto <D.50907>;
            <D.50906>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50908>;
            <D.50907>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50908>:
          }
          goto <D.50909>;
          <D.50894>:
          <D.50909>:
          <D.50892>:
          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.50910 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.50910;
          inst->prev = 0B;
          D.50911 = inst->prev;
          inst->next = D.50911;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.50912 = inst->sreg3;
          inst->sreg2 = D.50912;
          D.50913 = inst->sreg2;
          inst->sreg1 = D.50913;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.50914 = (unsigned char) __ins_flags;
          inst->flags = D.50914;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.50915>; else goto <D.50916>;
          <D.50915>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.50917>;
          <D.50916>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.50917>:
        }
        goto <D.50918>;
        <D.50889>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 64;
          D.50919 = __ins_flags & 32;
          if (D.50919 != 0) goto <D.50920>; else goto <D.50921>;
          <D.50920>:
          D.50866 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.50867 = D.50866 & 64;
          if (D.50867 != 0) goto <D.50922>; else goto <D.50923>;
          <D.50922>:
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50924 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50924;
            inst->prev = 0B;
            D.50925 = inst->prev;
            inst->next = D.50925;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50926 = inst->sreg3;
            inst->sreg2 = D.50926;
            D.50927 = inst->sreg2;
            inst->sreg1 = D.50927;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50928>; else goto <D.50929>;
            <D.50928>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50930>;
            <D.50929>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50930>:
          }
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50931 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50931;
            inst->prev = 0B;
            D.50932 = inst->prev;
            inst->next = D.50932;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50933 = inst->sreg3;
            inst->sreg2 = D.50933;
            D.50934 = inst->sreg2;
            inst->sreg1 = D.50934;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->data.op[1].p = "NullReferenceException";
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50935>; else goto <D.50936>;
            <D.50935>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50937>;
            <D.50936>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50937>:
          }
          goto <D.50938>;
          <D.50923>:
          <D.50938>:
          <D.50921>:
          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.50939 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.50939;
          inst->prev = 0B;
          D.50940 = inst->prev;
          inst->next = D.50940;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.50941 = inst->sreg3;
          inst->sreg2 = D.50941;
          D.50942 = inst->sreg2;
          inst->sreg1 = D.50942;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.50943 = (unsigned char) __ins_flags;
          inst->flags = D.50943;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.50944>; else goto <D.50945>;
          <D.50944>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.50946>;
          <D.50945>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.50946>:
        }
        <D.50918>:
        {
          struct MonoInst * inst;

          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.50947 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.50947;
          inst->prev = 0B;
          D.50948 = inst->prev;
          inst->next = D.50948;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.50949 = inst->sreg3;
          inst->sreg2 = D.50949;
          D.50950 = inst->sreg2;
          inst->sreg1 = D.50950;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = -1;
          inst->sreg1 = _length_reg;
          inst->sreg2 = index_reg;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.50951>; else goto <D.50952>;
          <D.50951>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.50953>;
          <D.50952>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.50953>:
        }
        {
          struct MonoInst * inst;

          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.50954 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.50954;
          inst->prev = 0B;
          D.50955 = inst->prev;
          inst->next = D.50955;
          inst->opcode = 459;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.50956 = inst->sreg3;
          inst->sreg2 = D.50956;
          D.50957 = inst->sreg2;
          inst->sreg1 = D.50957;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->data.op[1].p = "IndexOutOfRangeException";
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.50958>; else goto <D.50959>;
          <D.50958>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.50960>;
          <D.50959>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.50960>:
        }
      }
      goto <D.50961>;
      <D.50886>:
      {
        int _length_reg;

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

          __ins_flags = 32;
          D.50965 = __ins_flags & 32;
          if (D.50965 != 0) goto <D.50966>; else goto <D.50967>;
          <D.50966>:
          D.50866 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.50867 = D.50866 & 64;
          if (D.50867 != 0) goto <D.50968>; else goto <D.50969>;
          <D.50968>:
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50970 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50970;
            inst->prev = 0B;
            D.50971 = inst->prev;
            inst->next = D.50971;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50972 = inst->sreg3;
            inst->sreg2 = D.50972;
            D.50973 = inst->sreg2;
            inst->sreg1 = D.50973;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50974>; else goto <D.50975>;
            <D.50974>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50976>;
            <D.50975>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50976>:
          }
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50977 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50977;
            inst->prev = 0B;
            D.50978 = inst->prev;
            inst->next = D.50978;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.50979 = inst->sreg3;
            inst->sreg2 = D.50979;
            D.50980 = inst->sreg2;
            inst->sreg1 = D.50980;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->data.op[1].p = "NullReferenceException";
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.50981>; else goto <D.50982>;
            <D.50981>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.50983>;
            <D.50982>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.50983>:
          }
          goto <D.50984>;
          <D.50969>:
          <D.50984>:
          <D.50967>:
          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.50985 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.50985;
          inst->prev = 0B;
          D.50986 = inst->prev;
          inst->next = D.50986;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.50987 = inst->sreg3;
          inst->sreg2 = D.50987;
          D.50988 = inst->sreg2;
          inst->sreg1 = D.50988;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.50989 = (unsigned char) __ins_flags;
          inst->flags = D.50989;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.50990>; else goto <D.50991>;
          <D.50990>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.50992>;
          <D.50991>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.50992>:
        }
        goto <D.50993>;
        <D.50964>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 64;
          D.50994 = __ins_flags & 32;
          if (D.50994 != 0) goto <D.50995>; else goto <D.50996>;
          <D.50995>:
          D.50866 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.50867 = D.50866 & 64;
          if (D.50867 != 0) goto <D.50997>; else goto <D.50998>;
          <D.50997>:
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.50999 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.50999;
            inst->prev = 0B;
            D.51000 = inst->prev;
            inst->next = D.51000;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.51001 = inst->sreg3;
            inst->sreg2 = D.51001;
            D.51002 = inst->sreg2;
            inst->sreg1 = D.51002;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.51003>; else goto <D.51004>;
            <D.51003>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.51005>;
            <D.51004>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.51005>:
          }
          {
            struct MonoInst * inst;

            D.50830 = cfg->mempool;
            inst = mono_mempool_alloc (D.50830, 80);
            inst->data.op[1].const_val = 0;
            D.51006 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.51006;
            inst->prev = 0B;
            D.51007 = inst->prev;
            inst->next = D.51007;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.51008 = inst->sreg3;
            inst->sreg2 = D.51008;
            D.51009 = inst->sreg2;
            inst->sreg1 = D.51009;
            D.50838 = cfg->ip;
            inst->cil_code = D.50838;
            inst->data.op[1].p = "NullReferenceException";
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            if (D.50843 != 0B) goto <D.51010>; else goto <D.51011>;
            <D.51010>:
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            D.50843->next = inst;
            D.50842 = cfg->cbb;
            D.50843 = D.50842->last_ins;
            inst->prev = D.50843;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            goto <D.51012>;
            <D.51011>:
            D.50842 = cfg->cbb;
            D.50842 = cfg->cbb;
            D.50842->last_ins = inst;
            D.50843 = D.50842->last_ins;
            D.50842->code = D.50843;
            <D.51012>:
          }
          goto <D.51013>;
          <D.50998>:
          <D.51013>:
          <D.50996>:
          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.51014 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.51014;
          inst->prev = 0B;
          D.51015 = inst->prev;
          inst->next = D.51015;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.51016 = inst->sreg3;
          inst->sreg2 = D.51016;
          D.51017 = inst->sreg2;
          inst->sreg1 = D.51017;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.51018 = (unsigned char) __ins_flags;
          inst->flags = D.51018;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.51019>; else goto <D.51020>;
          <D.51019>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.51021>;
          <D.51020>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.51021>:
        }
        <D.50993>:
        {
          struct MonoInst * inst;

          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.51022 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.51022;
          inst->prev = 0B;
          D.51023 = inst->prev;
          inst->next = D.51023;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.51024 = inst->sreg3;
          inst->sreg2 = D.51024;
          D.51025 = inst->sreg2;
          inst->sreg1 = D.51025;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->dreg = -1;
          inst->sreg1 = _length_reg;
          inst->sreg2 = index_reg;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.51026>; else goto <D.51027>;
          <D.51026>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.51028>;
          <D.51027>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.51028>:
        }
        {
          struct MonoInst * inst;

          D.50830 = cfg->mempool;
          inst = mono_mempool_alloc (D.50830, 80);
          inst->data.op[1].const_val = 0;
          D.51029 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.51029;
          inst->prev = 0B;
          D.51030 = inst->prev;
          inst->next = D.51030;
          inst->opcode = 459;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.51031 = inst->sreg3;
          inst->sreg2 = D.51031;
          D.51032 = inst->sreg2;
          inst->sreg1 = D.51032;
          D.50838 = cfg->ip;
          inst->cil_code = D.50838;
          inst->data.op[1].p = "IndexOutOfRangeException";
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          if (D.50843 != 0B) goto <D.51033>; else goto <D.51034>;
          <D.51033>:
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          D.50843->next = inst;
          D.50842 = cfg->cbb;
          D.50843 = D.50842->last_ins;
          inst->prev = D.50843;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          goto <D.51035>;
          <D.51034>:
          D.50842 = cfg->cbb;
          D.50842 = cfg->cbb;
          D.50842->last_ins = inst;
          D.50843 = D.50842->last_ins;
          D.50842->code = D.50843;
          <D.51035>:
        }
      }
      <D.50961>:
      goto <D.51036>;
      <D.50865>:
      {
        struct MonoInst * ins;

        D.50830 = cfg->mempool;
        ins = mono_mempool_alloc (D.50830, 80);
        ins->data.op[1].const_val = 0;
        D.51037 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.51037;
        ins->prev = 0B;
        D.51038 = ins->prev;
        ins->next = D.51038;
        ins->opcode = 784;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.51039 = ins->sreg3;
        ins->sreg2 = D.51039;
        D.51040 = ins->sreg2;
        ins->sreg1 = D.51040;
        D.50838 = cfg->ip;
        ins->cil_code = D.50838;
        ins->sreg1 = array_reg;
        ins->sreg2 = index_reg;
        ins->data.op[1].const_val = 24;
        D.51041 = ins->flags;
        D.51042 = D.51041 | 32;
        ins->flags = D.51042;
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        if (D.50843 != 0B) goto <D.51043>; else goto <D.51044>;
        <D.51043>:
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        D.50843->next = ins;
        D.50842 = cfg->cbb;
        D.50843 = D.50842->last_ins;
        ins->prev = D.50843;
        D.50842 = cfg->cbb;
        D.50842->last_ins = ins;
        goto <D.51045>;
        <D.51044>:
        D.50842 = cfg->cbb;
        D.50842 = cfg->cbb;
        D.50842->last_ins = ins;
        D.50843 = D.50842->last_ins;
        D.50842->code = D.50843;
        <D.51045>:
        D.51046 = cfg->flags;
        D.51047 = D.51046 | 256;
        cfg->flags = D.51047;
        D.50842 = cfg->cbb;
        D.50842->has_array_access = 1;
      }
      <D.51036>:
      <D.50862>:
      <D.50858>:
      D.50830 = cfg->mempool;
      ins = mono_mempool_alloc (D.50830, 80);
      ins->data.op[1].const_val = 0;
      D.50831 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.50831;
      ins->prev = 0B;
      D.50832 = ins->prev;
      ins->next = D.50832;
      D.50833 = &klass->byval_arg;
      D.51048 = mono_type_to_store_membase (cfg, D.50833);
      D.51049 = (short unsigned int) D.51048;
      ins->opcode = D.51049;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.50836 = ins->sreg3;
      ins->sreg2 = D.50836;
      D.50837 = ins->sreg2;
      ins->sreg1 = D.50837;
      D.50838 = cfg->ip;
      ins->cil_code = D.50838;
      D.50792 = sp + 16;
      D.50793 = *D.50792;
      D.50839 = D.50793->dreg;
      ins->sreg1 = D.50839;
      ins->dreg = array_reg;
      D.51050 = (long int) offset;
      ins->data.op[0].const_val = D.51050;
      D.50833 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.50833, ins);
      D.50833 = &klass->byval_arg;
      D.51051 = mono_class_from_mono_type (D.50833);
      ins->klass = D.51051;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      if (D.50843 != 0B) goto <D.51052>; else goto <D.51053>;
      <D.51052>:
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      D.50843->next = ins;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      ins->prev = D.50843;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      goto <D.51054>;
      <D.51053>:
      D.50842 = cfg->cbb;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      D.50843 = D.50842->last_ins;
      D.50842->code = D.50843;
      <D.51054>:
    }
    goto <D.51055>;
    <D.50850>:
    {
      struct MonoInst * addr;

      D.50815 = *sp;
      D.50828 = sp + 8;
      D.50829 = *D.50828;
      addr = mini_emit_ldelema_1_ins (cfg, klass, D.50815, D.50829, safety_checks);
      D.50830 = cfg->mempool;
      ins = mono_mempool_alloc (D.50830, 80);
      ins->data.op[1].const_val = 0;
      D.50831 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.50831;
      ins->prev = 0B;
      D.50832 = ins->prev;
      ins->next = D.50832;
      D.50833 = &klass->byval_arg;
      D.51056 = mono_type_to_store_membase (cfg, D.50833);
      D.51057 = (short unsigned int) D.51056;
      ins->opcode = D.51057;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.50836 = ins->sreg3;
      ins->sreg2 = D.50836;
      D.50837 = ins->sreg2;
      ins->sreg1 = D.50837;
      D.50838 = cfg->ip;
      ins->cil_code = D.50838;
      D.50792 = sp + 16;
      D.50793 = *D.50792;
      D.50839 = D.50793->dreg;
      ins->sreg1 = D.50839;
      D.51058 = addr->dreg;
      ins->dreg = D.51058;
      ins->data.op[0].const_val = 0;
      D.50833 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.50833, ins);
      D.50833 = &klass->byval_arg;
      D.51059 = mono_class_from_mono_type (D.50833);
      ins->klass = D.51059;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      if (D.50843 != 0B) goto <D.51060>; else goto <D.51061>;
      <D.51060>:
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      D.50843->next = ins;
      D.50842 = cfg->cbb;
      D.50843 = D.50842->last_ins;
      ins->prev = D.50843;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      goto <D.51062>;
      <D.51061>:
      D.50842 = cfg->cbb;
      D.50842 = cfg->cbb;
      D.50842->last_ins = ins;
      D.50843 = D.50842->last_ins;
      D.50842->code = D.50843;
      <D.51062>:
      D.51063 = generic_class_is_reference_type (cfg, klass);
      if (D.51063 != 0) goto <D.51064>; else goto <D.51065>;
      <D.51064>:
      D.50792 = sp + 16;
      D.50793 = *D.50792;
      emit_write_barrier (cfg, addr, D.50793);
      <D.51065>:
    }
    <D.51055>:
    <D.50847>:
    D.50819 = ins;
    return D.50819;
  }
}


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.51068;
  struct MonoMethod * D.51069;
  int D.51070;
  struct MonoInst * D.51071;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.51068 = cfg->mempool;
  D.51069 = cfg->current_method;
  D.51070 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.51068, D.51069, D.51070, 13, field, rgctx_type);
  D.51069 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.51069, context_used);
  D.51071 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.51071;
}


emit_seq_point (struct MonoCompile * cfg, struct MonoMethod * method, guint8 * ip, gboolean intr_loc, gboolean nonempty_stack)
{
  long unsigned int D.51073;
  long unsigned int D.51074;
  struct MonoMethod * D.51077;
  struct MonoMemPool * D.51080;
  long int D.51081;
  struct MonoInst * D.51082;
  int D.51083;
  int D.51084;
  const unsigned char * D.51085;
  long int ip.495;
  struct MonoMethodHeader * D.51087;
  const unsigned char * D.51088;
  long int D.51089;
  long int D.51090;
  _Bool D.51091;
  unsigned char D.51092;
  unsigned char D.51095;
  unsigned char D.51096;
  struct MonoBasicBlock * D.51097;
  struct MonoInst * D.51098;
  struct MonoInst * ins;

  D.51073 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.51074 = D.51073 & 32;
  if (D.51074 != 0) goto <D.51075>; else goto <D.51076>;
  <D.51075>:
  D.51077 = cfg->method;
  if (D.51077 == method) goto <D.51078>; else goto <D.51079>;
  <D.51078>:
  D.51080 = cfg->mempool;
  ins = mono_mempool_alloc (D.51080, 80);
  ins->data.op[1].const_val = 0;
  D.51081 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51081;
  ins->prev = 0B;
  D.51082 = ins->prev;
  ins->next = D.51082;
  ins->opcode = 341;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51083 = ins->sreg3;
  ins->sreg2 = D.51083;
  D.51084 = ins->sreg2;
  ins->sreg1 = D.51084;
  D.51085 = cfg->ip;
  ins->cil_code = D.51085;
  ip.495 = (long int) ip;
  D.51087 = cfg->header;
  D.51088 = D.51087->code;
  D.51089 = (long int) D.51088;
  D.51090 = ip.495 - D.51089;
  ins->data.op[1].const_val = D.51090;
  D.51091 = intr_loc != 0;
  D.51092 = (unsigned char) D.51091;
  ins->flags = D.51092;
  if (nonempty_stack != 0) goto <D.51093>; else goto <D.51094>;
  <D.51093>:
  D.51095 = ins->flags;
  D.51096 = D.51095 | 4;
  ins->flags = D.51096;
  <D.51094>:
  D.51097 = cfg->cbb;
  D.51098 = D.51097->last_ins;
  if (D.51098 != 0B) goto <D.51099>; else goto <D.51100>;
  <D.51099>:
  D.51097 = cfg->cbb;
  D.51098 = D.51097->last_ins;
  D.51098->next = ins;
  D.51097 = cfg->cbb;
  D.51098 = D.51097->last_ins;
  ins->prev = D.51098;
  D.51097 = cfg->cbb;
  D.51097->last_ins = ins;
  goto <D.51101>;
  <D.51100>:
  D.51097 = cfg->cbb;
  D.51097 = cfg->cbb;
  D.51097->last_ins = ins;
  D.51098 = D.51097->last_ins;
  D.51097->code = D.51098;
  <D.51101>:
  <D.51079>:
  <D.51076>:
}


mono_find_final_block (struct MonoCompile * cfg, unsigned char * ip, unsigned char * target, int type)
{
  struct MonoExceptionClause * D.51102;
  long unsigned int D.51103;
  long unsigned int D.51104;
  unsigned int D.51107;
  long int D.51108;
  long int ip.496;
  const unsigned char * D.51110;
  long int D.51111;
  long int D.51112;
  unsigned int D.51115;
  unsigned int D.51116;
  long int D.51117;
  long int target.497;
  long int D.51121;
  unsigned int D.51123;
  unsigned int type.498;
  <unnamed-unsigned:15> D.51127;
  int D.51128;
  struct GList * D.51129;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;
  struct GList * res;

  header = cfg->header;
  res = 0B;
  i = 0;
  goto <D.25023>;
  <D.25022>:
  D.51102 = header->clauses;
  D.51103 = (long unsigned int) i;
  D.51104 = D.51103 * 32;
  clause = D.51102 + D.51104;
  D.51107 = clause->try_offset;
  D.51108 = (long int) D.51107;
  ip.496 = (long int) ip;
  D.51110 = header->code;
  D.51111 = (long int) D.51110;
  D.51112 = ip.496 - D.51111;
  if (D.51108 <= D.51112) goto <D.51113>; else goto <D.51114>;
  <D.51113>:
  ip.496 = (long int) ip;
  D.51110 = header->code;
  D.51111 = (long int) D.51110;
  D.51112 = ip.496 - D.51111;
  D.51107 = clause->try_offset;
  D.51115 = clause->try_len;
  D.51116 = D.51107 + D.51115;
  D.51117 = (long int) D.51116;
  if (D.51112 < D.51117) goto <D.51118>; else goto <D.51119>;
  <D.51118>:
  D.51107 = clause->try_offset;
  D.51108 = (long int) D.51107;
  target.497 = (long int) target;
  D.51110 = header->code;
  D.51111 = (long int) D.51110;
  D.51121 = target.497 - D.51111;
  if (D.51108 > D.51121) goto <D.51105>; else goto <D.51122>;
  <D.51122>:
  target.497 = (long int) target;
  D.51110 = header->code;
  D.51111 = (long int) D.51110;
  D.51121 = target.497 - D.51111;
  D.51107 = clause->try_offset;
  D.51115 = clause->try_len;
  D.51116 = D.51107 + D.51115;
  D.51117 = (long int) D.51116;
  if (D.51121 >= D.51117) goto <D.51105>; else goto <D.51106>;
  <D.51105>:
  D.51123 = clause->flags;
  type.498 = (unsigned int) type;
  if (D.51123 == type.498) goto <D.51125>; else goto <D.51126>;
  <D.51125>:
  res = monoeg_g_list_append (res, clause);
  <D.51126>:
  <D.51106>:
  <D.51119>:
  <D.51114>:
  i = i + 1;
  <D.25023>:
  D.51127 = header->num_clauses;
  D.51128 = (int) D.51127;
  if (D.51128 > i) goto <D.25022>; else goto <D.25024>;
  <D.25024>:
  D.51129 = res;
  return D.51129;
}


mono_get_domainvar (struct MonoCompile * cfg)
{
  struct MonoInst * D.51131;
  struct MonoClass * D.51134;
  struct MonoType * D.51135;
  struct MonoInst * D.51136;
  struct MonoInst * D.51137;

  D.51131 = cfg->domainvar;
  if (D.51131 == 0B) goto <D.51132>; else goto <D.51133>;
  <D.51132>:
  D.51134 = mono_defaults.int_class;
  D.51135 = &D.51134->byval_arg;
  D.51136 = mono_compile_create_var (cfg, D.51135, 329);
  cfg->domainvar = D.51136;
  <D.51133>:
  D.51137 = cfg->domainvar;
  return D.51137;
}


handle_cisinst (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src)
{
  unsigned int D.51139;
  unsigned int D.51140;
  struct MonoMemPool * D.51141;
  unsigned int D.51142;
  unsigned int D.51143;
  unsigned int D.51144;
  int D.51145;
  unsigned int D.51146;
  unsigned int D.51147;
  int D.51148;
  unsigned int D.51149;
  unsigned int D.51150;
  int D.51151;
  unsigned int D.51152;
  unsigned int D.51153;
  int D.51154;
  unsigned int D.51155;
  unsigned int D.51156;
  int D.51157;
  long int D.51158;
  struct MonoInst * D.51159;
  int D.51160;
  int D.51161;
  const unsigned char * D.51162;
  struct MonoBasicBlock * D.51163;
  struct MonoInst * D.51164;
  long int D.51168;
  struct MonoInst * D.51169;
  int D.51170;
  int D.51171;
  unsigned int D.51174;
  unsigned int D.51175;
  int D.51176;
  unsigned char * D.51180;
  struct MonoBasicBlock * * D.51183;
  long int D.51184;
  unsigned char * D.51185;
  long int D.51186;
  long int D.51187;
  long unsigned int D.51188;
  long unsigned int D.51189;
  struct MonoBasicBlock * * D.51190;
  unsigned int D.51191;
  short unsigned int D.51196;
  short unsigned int D.51197;
  short unsigned int D.51199;
  short unsigned int D.51201;
  struct MonoBasicBlock * * D.51202;
  struct MonoBasicBlock * * D.51203;
  struct MonoBasicBlock * D.51204;
  void * D.51214;
  struct MonoBasicBlock * * D.51215;
  struct MonoBasicBlock * * D.51216;
  long unsigned int D.51220;
  long unsigned int D.51221;
  unsigned int D.51224;
  unsigned int D.51225;
  int D.51226;
  unsigned int D.51244;
  unsigned int D.51245;
  unsigned int D.51248;
  unsigned int D.51249;
  int D.51250;
  unsigned int D.51251;
  long int D.51252;
  struct MonoInst * D.51253;
  int D.51254;
  int D.51255;
  unsigned char * D.51259;
  long int D.51262;
  long int D.51263;
  long unsigned int D.51264;
  long unsigned int D.51265;
  struct MonoBasicBlock * * D.51266;
  long int D.51281;
  struct MonoInst * D.51282;
  int D.51283;
  int D.51284;
  struct MonoClass * D.51288;
  unsigned int D.51289;
  long int D.51290;
  struct MonoInst * D.51291;
  int D.51292;
  int D.51293;
  long int D.51297;
  struct MonoInst * D.51298;
  int D.51299;
  int D.51300;
  long int D.51304;
  struct MonoInst * D.51305;
  int D.51306;
  int D.51307;
  unsigned int D.51310;
  unsigned int D.51311;
  int D.51312;
  unsigned char * D.51316;
  long int D.51319;
  long int D.51320;
  long unsigned int D.51321;
  long unsigned int D.51322;
  struct MonoBasicBlock * * D.51323;
  void * D.51339;
  struct MonoBasicBlock * * D.51340;
  struct MonoBasicBlock * * D.51341;
  unsigned int D.51347;
  unsigned int D.51348;
  int D.51349;
  unsigned int D.51368;
  long int D.51369;
  struct MonoInst * D.51370;
  int D.51371;
  int D.51372;
  long int D.51376;
  struct MonoInst * D.51377;
  int D.51378;
  int D.51379;
  unsigned int D.51383;
  long int D.51384;
  struct MonoInst * D.51385;
  int D.51386;
  int D.51387;
  long int D.51391;
  struct MonoInst * D.51392;
  int D.51393;
  int D.51394;
  unsigned int D.51398;
  long int D.51399;
  struct MonoInst * D.51400;
  int D.51401;
  int D.51402;
  long int D.51406;
  struct MonoInst * D.51407;
  int D.51408;
  int D.51409;
  long int D.51413;
  struct MonoInst * D.51414;
  int D.51415;
  int D.51416;
  unsigned int D.51419;
  unsigned int D.51420;
  int D.51421;
  unsigned char * D.51425;
  long int D.51428;
  long int D.51429;
  long unsigned int D.51430;
  long unsigned int D.51431;
  struct MonoBasicBlock * * D.51432;
  void * D.51448;
  struct MonoBasicBlock * * D.51449;
  struct MonoBasicBlock * * D.51450;
  unsigned int D.51456;
  unsigned int D.51457;
  int D.51458;
  long int D.51476;
  struct MonoInst * D.51477;
  int D.51478;
  int D.51479;
  unsigned int D.51482;
  unsigned int D.51483;
  int D.51484;
  unsigned char * D.51488;
  long int D.51491;
  long int D.51492;
  long unsigned int D.51493;
  long unsigned int D.51494;
  struct MonoBasicBlock * * D.51495;
  void * D.51511;
  struct MonoBasicBlock * * D.51512;
  struct MonoBasicBlock * * D.51513;
  unsigned int D.51519;
  unsigned int D.51520;
  int D.51521;
  unsigned char * D.51539;
  long int D.51542;
  long int D.51543;
  long unsigned int D.51544;
  long unsigned int D.51545;
  struct MonoBasicBlock * * D.51546;
  unsigned char * D.51561;
  long int D.51564;
  long int D.51565;
  long unsigned int D.51566;
  long unsigned int D.51567;
  struct MonoBasicBlock * * D.51568;
  long int D.51583;
  struct MonoInst * D.51584;
  int D.51585;
  int D.51586;
  long int D.51590;
  struct MonoInst * D.51591;
  int D.51592;
  int D.51593;
  unsigned int D.51596;
  unsigned int D.51597;
  int D.51598;
  unsigned char * D.51602;
  long int D.51605;
  long int D.51606;
  long unsigned int D.51607;
  long unsigned int D.51608;
  struct MonoBasicBlock * * D.51609;
  void * D.51625;
  struct MonoBasicBlock * * D.51626;
  struct MonoBasicBlock * * D.51627;
  unsigned int D.51633;
  unsigned int D.51634;
  int D.51635;
  unsigned char * D.51653;
  long int D.51656;
  long int D.51657;
  long unsigned int D.51658;
  long unsigned int D.51659;
  struct MonoBasicBlock * * D.51660;
  long int D.51675;
  struct MonoInst * D.51676;
  int D.51677;
  int D.51678;
  long int D.51682;
  struct MonoInst * D.51683;
  int D.51684;
  int D.51685;
  unsigned int D.51688;
  unsigned int D.51689;
  int D.51690;
  unsigned char * D.51694;
  long int D.51697;
  long int D.51698;
  long unsigned int D.51699;
  long unsigned int D.51700;
  struct MonoBasicBlock * * D.51701;
  void * D.51717;
  struct MonoBasicBlock * * D.51718;
  struct MonoBasicBlock * * D.51719;
  unsigned int D.51725;
  unsigned int D.51726;
  int D.51727;
  unsigned char * D.51745;
  long int D.51748;
  long int D.51749;
  long unsigned int D.51750;
  long unsigned int D.51751;
  struct MonoBasicBlock * * D.51752;
  long int D.51767;
  struct MonoInst * D.51768;
  int D.51769;
  int D.51770;
  unsigned char * D.51774;
  long int D.51777;
  long int D.51778;
  long unsigned int D.51779;
  long unsigned int D.51780;
  struct MonoBasicBlock * * D.51781;
  long int D.51796;
  struct MonoInst * D.51797;
  int D.51798;
  int D.51799;
  struct MonoInst * D.51800;
  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.51139 = alloc_ireg (cfg);
  dreg = (int) D.51139;
  D.51140 = alloc_preg (cfg);
  klass_reg = (int) D.51140;
  D.51141 = cfg->mempool;
  true_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51143 = D.51142;
  D.51144 = D.51143 + 1;
  cfg->num_bblocks = D.51144;
  D.51145 = (int) D.51143;
  true_bb->block_num = D.51145;
  D.51141 = cfg->mempool;
  false_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51146 = D.51142;
  D.51147 = D.51146 + 1;
  cfg->num_bblocks = D.51147;
  D.51148 = (int) D.51146;
  false_bb->block_num = D.51148;
  D.51141 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51149 = D.51142;
  D.51150 = D.51149 + 1;
  cfg->num_bblocks = D.51150;
  D.51151 = (int) D.51149;
  end_bb->block_num = D.51151;
  D.51141 = cfg->mempool;
  false2_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51152 = D.51142;
  D.51153 = D.51152 + 1;
  cfg->num_bblocks = D.51153;
  D.51154 = (int) D.51152;
  false2_bb->block_num = D.51154;
  D.51141 = cfg->mempool;
  no_proxy_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51155 = D.51142;
  D.51156 = D.51155 + 1;
  cfg->num_bblocks = D.51156;
  D.51157 = (int) D.51155;
  no_proxy_bb->block_num = D.51157;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51158 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51158;
    inst->prev = 0B;
    D.51159 = inst->prev;
    inst->next = D.51159;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51160 = inst->sreg3;
    inst->sreg2 = D.51160;
    D.51161 = inst->sreg2;
    inst->sreg1 = D.51161;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51165>; else goto <D.51166>;
    <D.51165>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51167>;
    <D.51166>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51167>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51168 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51168;
    ins->prev = 0B;
    D.51169 = ins->prev;
    ins->next = D.51169;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51170 = ins->sreg3;
    ins->sreg2 = D.51170;
    D.51171 = ins->sreg2;
    ins->sreg1 = D.51171;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (0 != 0) goto <D.51172>; else goto <D.51173>;
    <D.51172>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51174 = D.51142;
    D.51175 = D.51174 + 1;
    cfg->num_bblocks = D.51175;
    D.51176 = (int) D.51174;
    falsebb->block_num = D.51176;
    ins->data.op[0].target_block = false_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51177>; else goto <D.51178>;
    <D.51177>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51179>;
    <D.51178>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51179>:
    D.51180 = falsebb->cil_code;
    if (D.51180 != 0B) goto <D.51181>; else goto <D.51182>;
    <D.51181>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51180 = falsebb->cil_code;
    D.51184 = (long int) D.51180;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51187 = D.51184 - D.51186;
    D.51188 = (long unsigned int) D.51187;
    D.51189 = D.51188 * 8;
    D.51190 = D.51183 + D.51189;
    *D.51190 = falsebb;
    <D.51182>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51195>; else goto <D.51192>;
    <D.51195>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51193>; else goto <D.51198>;
    <D.51198>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51193>; else goto <D.51200>;
    <D.51200>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51193>; else goto <D.51192>;
    <D.51193>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51205>; else goto <D.51192>;
    <D.51205>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51194>;
    <D.51192>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51206>; else goto <D.51208>;
    <D.51208>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51209>; else goto <D.51207>;
    <D.51209>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51210>; else goto <D.51207>;
    <D.51210>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51211>; else goto <D.51207>;
    <D.51211>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51212>; else goto <D.51207>;
    <D.51212>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51206>; else goto <D.51207>;
    <D.51206>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51207>:
    <D.51194>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51213>;
    <D.51173>:
    D.51141 = cfg->mempool;
    D.51214 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51214;
    D.51215 = ins->data.op[1].many_blocks;
    *D.51215 = false_bb;
    D.51215 = ins->data.op[1].many_blocks;
    D.51216 = D.51215 + 8;
    *D.51216 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51217>; else goto <D.51218>;
    <D.51217>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51219>;
    <D.51218>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51219>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51222>; else goto <D.51223>;
    <D.51222>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51224 = D.51142;
    D.51225 = D.51224 + 1;
    cfg->num_bblocks = D.51225;
    D.51226 = (int) D.51224;
    falsebb->block_num = D.51226;
    D.51215 = ins->data.op[1].many_blocks;
    D.51216 = D.51215 + 8;
    *D.51216 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51180 = falsebb->cil_code;
    if (D.51180 != 0B) goto <D.51227>; else goto <D.51228>;
    <D.51227>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51180 = falsebb->cil_code;
    D.51184 = (long int) D.51180;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51187 = D.51184 - D.51186;
    D.51188 = (long unsigned int) D.51187;
    D.51189 = D.51188 * 8;
    D.51190 = D.51183 + D.51189;
    *D.51190 = falsebb;
    <D.51228>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51232>; else goto <D.51229>;
    <D.51232>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51230>; else goto <D.51233>;
    <D.51233>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51230>; else goto <D.51234>;
    <D.51234>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51230>; else goto <D.51229>;
    <D.51230>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51235>; else goto <D.51229>;
    <D.51235>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51231>;
    <D.51229>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51236>; else goto <D.51238>;
    <D.51238>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51239>; else goto <D.51237>;
    <D.51239>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51240>; else goto <D.51237>;
    <D.51240>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51241>; else goto <D.51237>;
    <D.51241>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51242>; else goto <D.51237>;
    <D.51242>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51236>; else goto <D.51237>;
    <D.51236>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51237>:
    <D.51231>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51243>;
    <D.51223>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51243>:
    <D.51213>:
  }
  D.51244 = klass->flags;
  D.51245 = D.51244 & 32;
  if (D.51245 != 0) goto <D.51246>; else goto <D.51247>;
  <D.51246>:
  D.51141 = cfg->mempool;
  interface_fail_bb = mono_mempool_alloc0 (D.51141, 296);
  D.51142 = cfg->num_bblocks;
  D.51248 = D.51142;
  D.51249 = D.51248 + 1;
  cfg->num_bblocks = D.51249;
  D.51250 = (int) D.51248;
  interface_fail_bb->block_num = D.51250;
  D.51251 = alloc_preg (cfg);
  tmp_reg = (int) D.51251;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51252 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51252;
    inst->prev = 0B;
    D.51253 = inst->prev;
    inst->next = D.51253;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51254 = inst->sreg3;
    inst->sreg2 = D.51254;
    D.51255 = inst->sreg2;
    inst->sreg1 = D.51255;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51256>; else goto <D.51257>;
    <D.51256>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51258>;
    <D.51257>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51258>:
  }
  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, true_bb);
  D.51259 = interface_fail_bb->cil_code;
  if (D.51259 != 0B) goto <D.51260>; else goto <D.51261>;
  <D.51260>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51259 = interface_fail_bb->cil_code;
  D.51262 = (long int) D.51259;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51263 = D.51262 - D.51186;
  D.51264 = (long unsigned int) D.51263;
  D.51265 = D.51264 * 8;
  D.51266 = D.51183 + D.51265;
  *D.51266 = interface_fail_bb;
  <D.51261>:
  D.51191 = cfg->real_offset;
  interface_fail_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51270>; else goto <D.51267>;
  <D.51270>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51268>; else goto <D.51271>;
  <D.51271>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51268>; else goto <D.51272>;
  <D.51272>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51268>; else goto <D.51267>;
  <D.51268>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51273>; else goto <D.51267>;
  <D.51273>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = interface_fail_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, interface_fail_bb);
  goto <D.51269>;
  <D.51267>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51274>; else goto <D.51276>;
  <D.51276>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51277>; else goto <D.51275>;
  <D.51277>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51278>; else goto <D.51275>;
  <D.51278>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51279>; else goto <D.51275>;
  <D.51279>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51280>; else goto <D.51275>;
  <D.51280>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51274>; else goto <D.51275>;
  <D.51274>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, interface_fail_bb);
  <D.51275>:
  <D.51269>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = interface_fail_bb;
  cfg->cbb = interface_fail_bb;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51281 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51281;
    inst->prev = 0B;
    D.51282 = inst->prev;
    inst->next = D.51282;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51283 = inst->sreg3;
    inst->sreg2 = D.51283;
    D.51284 = inst->sreg2;
    inst->sreg1 = D.51284;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51285>; else goto <D.51286>;
    <D.51285>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51287>;
    <D.51286>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51287>:
  }
  D.51288 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.51288, 556, false_bb);
  D.51289 = alloc_preg (cfg);
  tmp_reg = (int) D.51289;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51290 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51290;
    inst->prev = 0B;
    D.51291 = inst->prev;
    inst->next = D.51291;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51292 = inst->sreg3;
    inst->sreg2 = D.51292;
    D.51293 = inst->sreg2;
    inst->sreg1 = D.51293;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51294>; else goto <D.51295>;
    <D.51294>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51296>;
    <D.51295>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51296>:
  }
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51297 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51297;
    inst->prev = 0B;
    D.51298 = inst->prev;
    inst->next = D.51298;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51299 = inst->sreg3;
    inst->sreg2 = D.51299;
    D.51300 = inst->sreg2;
    inst->sreg1 = D.51300;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51301>; else goto <D.51302>;
    <D.51301>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51303>;
    <D.51302>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51303>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51304 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51304;
    ins->prev = 0B;
    D.51305 = ins->prev;
    ins->next = D.51305;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51306 = ins->sreg3;
    ins->sreg2 = D.51306;
    D.51307 = ins->sreg2;
    ins->sreg1 = D.51307;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (0 != 0) goto <D.51308>; else goto <D.51309>;
    <D.51308>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51310 = D.51142;
    D.51311 = D.51310 + 1;
    cfg->num_bblocks = D.51311;
    D.51312 = (int) D.51310;
    falsebb->block_num = D.51312;
    ins->data.op[0].target_block = false2_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false2_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51313>; else goto <D.51314>;
    <D.51313>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51315>;
    <D.51314>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51315>:
    D.51316 = falsebb->cil_code;
    if (D.51316 != 0B) goto <D.51317>; else goto <D.51318>;
    <D.51317>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51316 = falsebb->cil_code;
    D.51319 = (long int) D.51316;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51320 = D.51319 - D.51186;
    D.51321 = (long unsigned int) D.51320;
    D.51322 = D.51321 * 8;
    D.51323 = D.51183 + D.51322;
    *D.51323 = falsebb;
    <D.51318>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51327>; else goto <D.51324>;
    <D.51327>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51325>; else goto <D.51328>;
    <D.51328>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51325>; else goto <D.51329>;
    <D.51329>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51325>; else goto <D.51324>;
    <D.51325>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51330>; else goto <D.51324>;
    <D.51330>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51326>;
    <D.51324>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51331>; else goto <D.51333>;
    <D.51333>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51334>; else goto <D.51332>;
    <D.51334>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51335>; else goto <D.51332>;
    <D.51335>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51336>; else goto <D.51332>;
    <D.51336>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51337>; else goto <D.51332>;
    <D.51337>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51331>; else goto <D.51332>;
    <D.51331>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51332>:
    <D.51326>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51338>;
    <D.51309>:
    D.51141 = cfg->mempool;
    D.51339 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51339;
    D.51340 = ins->data.op[1].many_blocks;
    *D.51340 = false2_bb;
    D.51340 = ins->data.op[1].many_blocks;
    D.51341 = D.51340 + 8;
    *D.51341 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false2_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51342>; else goto <D.51343>;
    <D.51342>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51344>;
    <D.51343>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51344>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51345>; else goto <D.51346>;
    <D.51345>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51347 = D.51142;
    D.51348 = D.51347 + 1;
    cfg->num_bblocks = D.51348;
    D.51349 = (int) D.51347;
    falsebb->block_num = D.51349;
    D.51340 = ins->data.op[1].many_blocks;
    D.51341 = D.51340 + 8;
    *D.51341 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51316 = falsebb->cil_code;
    if (D.51316 != 0B) goto <D.51350>; else goto <D.51351>;
    <D.51350>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51316 = falsebb->cil_code;
    D.51319 = (long int) D.51316;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51320 = D.51319 - D.51186;
    D.51321 = (long unsigned int) D.51320;
    D.51322 = D.51321 * 8;
    D.51323 = D.51183 + D.51322;
    *D.51323 = falsebb;
    <D.51351>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51355>; else goto <D.51352>;
    <D.51355>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51353>; else goto <D.51356>;
    <D.51356>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51353>; else goto <D.51357>;
    <D.51357>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51353>; else goto <D.51352>;
    <D.51353>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51358>; else goto <D.51352>;
    <D.51358>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51354>;
    <D.51352>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51359>; else goto <D.51361>;
    <D.51361>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51362>; else goto <D.51360>;
    <D.51362>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51363>; else goto <D.51360>;
    <D.51363>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51364>; else goto <D.51360>;
    <D.51364>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51365>; else goto <D.51360>;
    <D.51365>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51359>; else goto <D.51360>;
    <D.51359>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51360>:
    <D.51354>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51366>;
    <D.51346>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51366>:
    <D.51338>:
  }
  goto <D.51367>;
  <D.51247>:
  D.51368 = alloc_preg (cfg);
  tmp_reg = (int) D.51368;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51369 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51369;
    inst->prev = 0B;
    D.51370 = inst->prev;
    inst->next = D.51370;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51371 = inst->sreg3;
    inst->sreg2 = D.51371;
    D.51372 = inst->sreg2;
    inst->sreg1 = D.51372;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51373>; else goto <D.51374>;
    <D.51373>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51375>;
    <D.51374>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51375>:
  }
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51376 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51376;
    inst->prev = 0B;
    D.51377 = inst->prev;
    inst->next = D.51377;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51378 = inst->sreg3;
    inst->sreg2 = D.51378;
    D.51379 = inst->sreg2;
    inst->sreg1 = D.51379;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51380>; else goto <D.51381>;
    <D.51380>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51382>;
    <D.51381>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51382>:
  }
  D.51288 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.51288, 556, no_proxy_bb);
  D.51383 = alloc_preg (cfg);
  tmp_reg = (int) D.51383;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51384 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51384;
    inst->prev = 0B;
    D.51385 = inst->prev;
    inst->next = D.51385;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51386 = inst->sreg3;
    inst->sreg2 = D.51386;
    D.51387 = inst->sreg2;
    inst->sreg1 = D.51387;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 24;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51388>; else goto <D.51389>;
    <D.51388>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51390>;
    <D.51389>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51390>:
  }
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51391 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51391;
    inst->prev = 0B;
    D.51392 = inst->prev;
    inst->next = D.51392;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51393 = inst->sreg3;
    inst->sreg2 = D.51393;
    D.51394 = inst->sreg2;
    inst->sreg1 = D.51394;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 16;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51395>; else goto <D.51396>;
    <D.51395>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51397>;
    <D.51396>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51397>:
  }
  D.51398 = alloc_preg (cfg);
  tmp_reg = (int) D.51398;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51399 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51399;
    inst->prev = 0B;
    D.51400 = inst->prev;
    inst->next = D.51400;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51401 = inst->sreg3;
    inst->sreg2 = D.51401;
    D.51402 = inst->sreg2;
    inst->sreg1 = D.51402;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51403>; else goto <D.51404>;
    <D.51403>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51405>;
    <D.51404>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51405>:
  }
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51406 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51406;
    inst->prev = 0B;
    D.51407 = inst->prev;
    inst->next = D.51407;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51408 = inst->sreg3;
    inst->sreg2 = D.51408;
    D.51409 = inst->sreg2;
    inst->sreg1 = D.51409;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51410>; else goto <D.51411>;
    <D.51410>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51412>;
    <D.51411>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51412>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51413 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51413;
    ins->prev = 0B;
    D.51414 = ins->prev;
    ins->next = D.51414;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51415 = ins->sreg3;
    ins->sreg2 = D.51415;
    D.51416 = ins->sreg2;
    ins->sreg1 = D.51416;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (0 != 0) goto <D.51417>; else goto <D.51418>;
    <D.51417>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51419 = D.51142;
    D.51420 = D.51419 + 1;
    cfg->num_bblocks = D.51420;
    D.51421 = (int) D.51419;
    falsebb->block_num = D.51421;
    ins->data.op[0].target_block = no_proxy_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, no_proxy_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51422>; else goto <D.51423>;
    <D.51422>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51424>;
    <D.51423>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51424>:
    D.51425 = falsebb->cil_code;
    if (D.51425 != 0B) goto <D.51426>; else goto <D.51427>;
    <D.51426>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51425 = falsebb->cil_code;
    D.51428 = (long int) D.51425;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51429 = D.51428 - D.51186;
    D.51430 = (long unsigned int) D.51429;
    D.51431 = D.51430 * 8;
    D.51432 = D.51183 + D.51431;
    *D.51432 = falsebb;
    <D.51427>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51436>; else goto <D.51433>;
    <D.51436>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51434>; else goto <D.51437>;
    <D.51437>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51434>; else goto <D.51438>;
    <D.51438>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51434>; else goto <D.51433>;
    <D.51434>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51439>; else goto <D.51433>;
    <D.51439>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51435>;
    <D.51433>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51440>; else goto <D.51442>;
    <D.51442>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51443>; else goto <D.51441>;
    <D.51443>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51444>; else goto <D.51441>;
    <D.51444>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51445>; else goto <D.51441>;
    <D.51445>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51446>; else goto <D.51441>;
    <D.51446>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51440>; else goto <D.51441>;
    <D.51440>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51441>:
    <D.51435>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51447>;
    <D.51418>:
    D.51141 = cfg->mempool;
    D.51448 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51448;
    D.51449 = ins->data.op[1].many_blocks;
    *D.51449 = no_proxy_bb;
    D.51449 = ins->data.op[1].many_blocks;
    D.51450 = D.51449 + 8;
    *D.51450 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, no_proxy_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51451>; else goto <D.51452>;
    <D.51451>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51453>;
    <D.51452>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51453>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51454>; else goto <D.51455>;
    <D.51454>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51456 = D.51142;
    D.51457 = D.51456 + 1;
    cfg->num_bblocks = D.51457;
    D.51458 = (int) D.51456;
    falsebb->block_num = D.51458;
    D.51449 = ins->data.op[1].many_blocks;
    D.51450 = D.51449 + 8;
    *D.51450 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51425 = falsebb->cil_code;
    if (D.51425 != 0B) goto <D.51459>; else goto <D.51460>;
    <D.51459>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51425 = falsebb->cil_code;
    D.51428 = (long int) D.51425;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51429 = D.51428 - D.51186;
    D.51430 = (long unsigned int) D.51429;
    D.51431 = D.51430 * 8;
    D.51432 = D.51183 + D.51431;
    *D.51432 = falsebb;
    <D.51460>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51464>; else goto <D.51461>;
    <D.51464>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51462>; else goto <D.51465>;
    <D.51465>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51462>; else goto <D.51466>;
    <D.51466>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51462>; else goto <D.51461>;
    <D.51462>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51467>; else goto <D.51461>;
    <D.51467>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51463>;
    <D.51461>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51468>; else goto <D.51470>;
    <D.51470>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51471>; else goto <D.51469>;
    <D.51471>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51472>; else goto <D.51469>;
    <D.51472>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51473>; else goto <D.51469>;
    <D.51473>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51474>; else goto <D.51469>;
    <D.51474>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51468>; else goto <D.51469>;
    <D.51468>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51469>:
    <D.51463>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51475>;
    <D.51455>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51475>:
    <D.51447>:
  }
  mini_emit_isninst_cast (cfg, klass_reg, klass, false2_bb, true_bb);
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51476 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51476;
    ins->prev = 0B;
    D.51477 = ins->prev;
    ins->next = D.51477;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51478 = ins->sreg3;
    ins->sreg2 = D.51478;
    D.51479 = ins->sreg2;
    ins->sreg1 = D.51479;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (1 != 0) goto <D.51480>; else goto <D.51481>;
    <D.51480>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51482 = D.51142;
    D.51483 = D.51482 + 1;
    cfg->num_bblocks = D.51483;
    D.51484 = (int) D.51482;
    falsebb->block_num = D.51484;
    ins->data.op[0].target_block = false2_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false2_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51485>; else goto <D.51486>;
    <D.51485>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51487>;
    <D.51486>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51487>:
    D.51488 = falsebb->cil_code;
    if (D.51488 != 0B) goto <D.51489>; else goto <D.51490>;
    <D.51489>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51488 = falsebb->cil_code;
    D.51491 = (long int) D.51488;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51492 = D.51491 - D.51186;
    D.51493 = (long unsigned int) D.51492;
    D.51494 = D.51493 * 8;
    D.51495 = D.51183 + D.51494;
    *D.51495 = falsebb;
    <D.51490>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51499>; else goto <D.51496>;
    <D.51499>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51497>; else goto <D.51500>;
    <D.51500>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51497>; else goto <D.51501>;
    <D.51501>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51497>; else goto <D.51496>;
    <D.51497>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51502>; else goto <D.51496>;
    <D.51502>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51498>;
    <D.51496>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51503>; else goto <D.51505>;
    <D.51505>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51506>; else goto <D.51504>;
    <D.51506>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51507>; else goto <D.51504>;
    <D.51507>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51508>; else goto <D.51504>;
    <D.51508>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51509>; else goto <D.51504>;
    <D.51509>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51503>; else goto <D.51504>;
    <D.51503>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51504>:
    <D.51498>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51510>;
    <D.51481>:
    D.51141 = cfg->mempool;
    D.51511 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51511;
    D.51512 = ins->data.op[1].many_blocks;
    *D.51512 = false2_bb;
    D.51512 = ins->data.op[1].many_blocks;
    D.51513 = D.51512 + 8;
    *D.51513 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, false2_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51514>; else goto <D.51515>;
    <D.51514>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51516>;
    <D.51515>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51516>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51517>; else goto <D.51518>;
    <D.51517>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51519 = D.51142;
    D.51520 = D.51519 + 1;
    cfg->num_bblocks = D.51520;
    D.51521 = (int) D.51519;
    falsebb->block_num = D.51521;
    D.51512 = ins->data.op[1].many_blocks;
    D.51513 = D.51512 + 8;
    *D.51513 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51488 = falsebb->cil_code;
    if (D.51488 != 0B) goto <D.51522>; else goto <D.51523>;
    <D.51522>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51488 = falsebb->cil_code;
    D.51491 = (long int) D.51488;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51492 = D.51491 - D.51186;
    D.51493 = (long unsigned int) D.51492;
    D.51494 = D.51493 * 8;
    D.51495 = D.51183 + D.51494;
    *D.51495 = falsebb;
    <D.51523>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51527>; else goto <D.51524>;
    <D.51527>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51525>; else goto <D.51528>;
    <D.51528>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51525>; else goto <D.51529>;
    <D.51529>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51525>; else goto <D.51524>;
    <D.51525>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51530>; else goto <D.51524>;
    <D.51530>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51526>;
    <D.51524>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51531>; else goto <D.51533>;
    <D.51533>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51534>; else goto <D.51532>;
    <D.51534>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51535>; else goto <D.51532>;
    <D.51535>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51536>; else goto <D.51532>;
    <D.51536>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51537>; else goto <D.51532>;
    <D.51537>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51531>; else goto <D.51532>;
    <D.51531>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51532>:
    <D.51526>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51538>;
    <D.51518>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51538>:
    <D.51510>:
  }
  D.51539 = no_proxy_bb->cil_code;
  if (D.51539 != 0B) goto <D.51540>; else goto <D.51541>;
  <D.51540>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51539 = no_proxy_bb->cil_code;
  D.51542 = (long int) D.51539;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51543 = D.51542 - D.51186;
  D.51544 = (long unsigned int) D.51543;
  D.51545 = D.51544 * 8;
  D.51546 = D.51183 + D.51545;
  *D.51546 = no_proxy_bb;
  <D.51541>:
  D.51191 = cfg->real_offset;
  no_proxy_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51550>; else goto <D.51547>;
  <D.51550>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51548>; else goto <D.51551>;
  <D.51551>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51548>; else goto <D.51552>;
  <D.51552>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51548>; else goto <D.51547>;
  <D.51548>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51553>; else goto <D.51547>;
  <D.51553>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = no_proxy_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, no_proxy_bb);
  goto <D.51549>;
  <D.51547>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51554>; else goto <D.51556>;
  <D.51556>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51557>; else goto <D.51555>;
  <D.51557>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51558>; else goto <D.51555>;
  <D.51558>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51559>; else goto <D.51555>;
  <D.51559>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51560>; else goto <D.51555>;
  <D.51560>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51554>; else goto <D.51555>;
  <D.51554>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, no_proxy_bb);
  <D.51555>:
  <D.51549>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = no_proxy_bb;
  cfg->cbb = no_proxy_bb;
  mini_emit_isninst_cast (cfg, klass_reg, klass, false_bb, true_bb);
  <D.51367>:
  D.51561 = false_bb->cil_code;
  if (D.51561 != 0B) goto <D.51562>; else goto <D.51563>;
  <D.51562>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51561 = false_bb->cil_code;
  D.51564 = (long int) D.51561;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51565 = D.51564 - D.51186;
  D.51566 = (long unsigned int) D.51565;
  D.51567 = D.51566 * 8;
  D.51568 = D.51183 + D.51567;
  *D.51568 = false_bb;
  <D.51563>:
  D.51191 = cfg->real_offset;
  false_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51572>; else goto <D.51569>;
  <D.51572>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51570>; else goto <D.51573>;
  <D.51573>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51570>; else goto <D.51574>;
  <D.51574>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51570>; else goto <D.51569>;
  <D.51570>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51575>; else goto <D.51569>;
  <D.51575>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = false_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, false_bb);
  goto <D.51571>;
  <D.51569>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51576>; else goto <D.51578>;
  <D.51578>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51579>; else goto <D.51577>;
  <D.51579>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51580>; else goto <D.51577>;
  <D.51580>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51581>; else goto <D.51577>;
  <D.51581>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51582>; else goto <D.51577>;
  <D.51582>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51576>; else goto <D.51577>;
  <D.51576>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, false_bb);
  <D.51577>:
  <D.51571>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = false_bb;
  cfg->cbb = false_bb;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51583 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51583;
    inst->prev = 0B;
    D.51584 = inst->prev;
    inst->next = D.51584;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51585 = inst->sreg3;
    inst->sreg2 = D.51585;
    D.51586 = inst->sreg2;
    inst->sreg1 = D.51586;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51587>; else goto <D.51588>;
    <D.51587>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51589>;
    <D.51588>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51589>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51590 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51590;
    ins->prev = 0B;
    D.51591 = ins->prev;
    ins->next = D.51591;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51592 = ins->sreg3;
    ins->sreg2 = D.51592;
    D.51593 = ins->sreg2;
    ins->sreg1 = D.51593;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (1 != 0) goto <D.51594>; else goto <D.51595>;
    <D.51594>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51596 = D.51142;
    D.51597 = D.51596 + 1;
    cfg->num_bblocks = D.51597;
    D.51598 = (int) D.51596;
    falsebb->block_num = D.51598;
    ins->data.op[0].target_block = end_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, end_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51599>; else goto <D.51600>;
    <D.51599>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51601>;
    <D.51600>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51601>:
    D.51602 = falsebb->cil_code;
    if (D.51602 != 0B) goto <D.51603>; else goto <D.51604>;
    <D.51603>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51602 = falsebb->cil_code;
    D.51605 = (long int) D.51602;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51606 = D.51605 - D.51186;
    D.51607 = (long unsigned int) D.51606;
    D.51608 = D.51607 * 8;
    D.51609 = D.51183 + D.51608;
    *D.51609 = falsebb;
    <D.51604>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51613>; else goto <D.51610>;
    <D.51613>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51611>; else goto <D.51614>;
    <D.51614>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51611>; else goto <D.51615>;
    <D.51615>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51611>; else goto <D.51610>;
    <D.51611>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51616>; else goto <D.51610>;
    <D.51616>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51612>;
    <D.51610>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51617>; else goto <D.51619>;
    <D.51619>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51620>; else goto <D.51618>;
    <D.51620>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51621>; else goto <D.51618>;
    <D.51621>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51622>; else goto <D.51618>;
    <D.51622>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51623>; else goto <D.51618>;
    <D.51623>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51617>; else goto <D.51618>;
    <D.51617>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51618>:
    <D.51612>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51624>;
    <D.51595>:
    D.51141 = cfg->mempool;
    D.51625 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51625;
    D.51626 = ins->data.op[1].many_blocks;
    *D.51626 = end_bb;
    D.51626 = ins->data.op[1].many_blocks;
    D.51627 = D.51626 + 8;
    *D.51627 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, end_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51628>; else goto <D.51629>;
    <D.51628>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51630>;
    <D.51629>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51630>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51631>; else goto <D.51632>;
    <D.51631>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51633 = D.51142;
    D.51634 = D.51633 + 1;
    cfg->num_bblocks = D.51634;
    D.51635 = (int) D.51633;
    falsebb->block_num = D.51635;
    D.51626 = ins->data.op[1].many_blocks;
    D.51627 = D.51626 + 8;
    *D.51627 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51602 = falsebb->cil_code;
    if (D.51602 != 0B) goto <D.51636>; else goto <D.51637>;
    <D.51636>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51602 = falsebb->cil_code;
    D.51605 = (long int) D.51602;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51606 = D.51605 - D.51186;
    D.51607 = (long unsigned int) D.51606;
    D.51608 = D.51607 * 8;
    D.51609 = D.51183 + D.51608;
    *D.51609 = falsebb;
    <D.51637>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51641>; else goto <D.51638>;
    <D.51641>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51639>; else goto <D.51642>;
    <D.51642>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51639>; else goto <D.51643>;
    <D.51643>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51639>; else goto <D.51638>;
    <D.51639>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51644>; else goto <D.51638>;
    <D.51644>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51640>;
    <D.51638>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51645>; else goto <D.51647>;
    <D.51647>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51648>; else goto <D.51646>;
    <D.51648>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51649>; else goto <D.51646>;
    <D.51649>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51650>; else goto <D.51646>;
    <D.51650>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51651>; else goto <D.51646>;
    <D.51651>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51645>; else goto <D.51646>;
    <D.51645>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51646>:
    <D.51640>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51652>;
    <D.51632>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51652>:
    <D.51624>:
  }
  D.51653 = false2_bb->cil_code;
  if (D.51653 != 0B) goto <D.51654>; else goto <D.51655>;
  <D.51654>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51653 = false2_bb->cil_code;
  D.51656 = (long int) D.51653;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51657 = D.51656 - D.51186;
  D.51658 = (long unsigned int) D.51657;
  D.51659 = D.51658 * 8;
  D.51660 = D.51183 + D.51659;
  *D.51660 = false2_bb;
  <D.51655>:
  D.51191 = cfg->real_offset;
  false2_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51664>; else goto <D.51661>;
  <D.51664>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51662>; else goto <D.51665>;
  <D.51665>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51662>; else goto <D.51666>;
  <D.51666>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51662>; else goto <D.51661>;
  <D.51662>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51667>; else goto <D.51661>;
  <D.51667>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = false2_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, false2_bb);
  goto <D.51663>;
  <D.51661>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51668>; else goto <D.51670>;
  <D.51670>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51671>; else goto <D.51669>;
  <D.51671>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51672>; else goto <D.51669>;
  <D.51672>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51673>; else goto <D.51669>;
  <D.51673>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51674>; else goto <D.51669>;
  <D.51674>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51668>; else goto <D.51669>;
  <D.51668>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, false2_bb);
  <D.51669>:
  <D.51663>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = false2_bb;
  cfg->cbb = false2_bb;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51675 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51675;
    inst->prev = 0B;
    D.51676 = inst->prev;
    inst->next = D.51676;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51677 = inst->sreg3;
    inst->sreg2 = D.51677;
    D.51678 = inst->sreg2;
    inst->sreg1 = D.51678;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 2;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51679>; else goto <D.51680>;
    <D.51679>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51681>;
    <D.51680>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51681>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51141 = cfg->mempool;
    ins = mono_mempool_alloc (D.51141, 80);
    ins->data.op[1].const_val = 0;
    D.51682 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51682;
    ins->prev = 0B;
    D.51683 = ins->prev;
    ins->next = D.51683;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51684 = ins->sreg3;
    ins->sreg2 = D.51684;
    D.51685 = ins->sreg2;
    ins->sreg1 = D.51685;
    D.51162 = cfg->ip;
    ins->cil_code = D.51162;
    if (1 != 0) goto <D.51686>; else goto <D.51687>;
    <D.51686>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51688 = D.51142;
    D.51689 = D.51688 + 1;
    cfg->num_bblocks = D.51689;
    D.51690 = (int) D.51688;
    falsebb->block_num = D.51690;
    ins->data.op[0].target_block = end_bb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, end_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51691>; else goto <D.51692>;
    <D.51691>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51693>;
    <D.51692>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51693>:
    D.51694 = falsebb->cil_code;
    if (D.51694 != 0B) goto <D.51695>; else goto <D.51696>;
    <D.51695>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51694 = falsebb->cil_code;
    D.51697 = (long int) D.51694;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51698 = D.51697 - D.51186;
    D.51699 = (long unsigned int) D.51698;
    D.51700 = D.51699 * 8;
    D.51701 = D.51183 + D.51700;
    *D.51701 = falsebb;
    <D.51696>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51705>; else goto <D.51702>;
    <D.51705>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51703>; else goto <D.51706>;
    <D.51706>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51703>; else goto <D.51707>;
    <D.51707>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51703>; else goto <D.51702>;
    <D.51703>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51708>; else goto <D.51702>;
    <D.51708>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51704>;
    <D.51702>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51709>; else goto <D.51711>;
    <D.51711>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51712>; else goto <D.51710>;
    <D.51712>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51713>; else goto <D.51710>;
    <D.51713>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51714>; else goto <D.51710>;
    <D.51714>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51715>; else goto <D.51710>;
    <D.51715>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51709>; else goto <D.51710>;
    <D.51709>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51710>:
    <D.51704>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51716>;
    <D.51687>:
    D.51141 = cfg->mempool;
    D.51717 = mono_mempool_alloc (D.51141, 16);
    ins->data.op[1].many_blocks = D.51717;
    D.51718 = ins->data.op[1].many_blocks;
    *D.51718 = end_bb;
    D.51718 = ins->data.op[1].many_blocks;
    D.51719 = D.51718 + 8;
    *D.51719 = 0B;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, end_bb);
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51720>; else goto <D.51721>;
    <D.51720>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = ins;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    ins->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    goto <D.51722>;
    <D.51721>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = ins;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51722>:
    D.51220 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51221 = D.51220 & 34359738368;
    if (D.51221 == 0) goto <D.51723>; else goto <D.51724>;
    <D.51723>:
    D.51141 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51141, 296);
    D.51142 = cfg->num_bblocks;
    D.51725 = D.51142;
    D.51726 = D.51725 + 1;
    cfg->num_bblocks = D.51726;
    D.51727 = (int) D.51725;
    falsebb->block_num = D.51727;
    D.51718 = ins->data.op[1].many_blocks;
    D.51719 = D.51718 + 8;
    *D.51719 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    D.51694 = falsebb->cil_code;
    if (D.51694 != 0B) goto <D.51728>; else goto <D.51729>;
    <D.51728>:
    D.51183 = cfg->cil_offset_to_bb;
    D.51694 = falsebb->cil_code;
    D.51697 = (long int) D.51694;
    D.51185 = cfg->cil_start;
    D.51186 = (long int) D.51185;
    D.51698 = D.51697 - D.51186;
    D.51699 = (long unsigned int) D.51698;
    D.51700 = D.51699 * 8;
    D.51701 = D.51183 + D.51700;
    *D.51701 = falsebb;
    <D.51729>:
    D.51191 = cfg->real_offset;
    falsebb->real_offset = D.51191;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51733>; else goto <D.51730>;
    <D.51733>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 <= 9) goto <D.51731>; else goto <D.51734>;
    <D.51734>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 <= 9) goto <D.51731>; else goto <D.51735>;
    <D.51735>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 <= 9) goto <D.51731>; else goto <D.51730>;
    <D.51731>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    D.51204 = *D.51203;
    if (D.51204 == 0B) goto <D.51736>; else goto <D.51730>;
    <D.51736>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51202 = D.51164->data.op[1].many_blocks;
    D.51203 = D.51202 + 8;
    *D.51203 = falsebb;
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    goto <D.51732>;
    <D.51730>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 == 0B) goto <D.51737>; else goto <D.51739>;
    <D.51739>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 442) goto <D.51740>; else goto <D.51738>;
    <D.51740>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    if (D.51196 != 759) goto <D.51741>; else goto <D.51738>;
    <D.51741>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51197 = D.51196 + 64985;
    if (D.51197 > 9) goto <D.51742>; else goto <D.51738>;
    <D.51742>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51199 = D.51196 + 64878;
    if (D.51199 > 9) goto <D.51743>; else goto <D.51738>;
    <D.51743>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51196 = D.51164->opcode;
    D.51201 = D.51196 + 64888;
    if (D.51201 > 9) goto <D.51737>; else goto <D.51738>;
    <D.51737>:
    D.51163 = cfg->cbb;
    mono_link_bblock (cfg, D.51163, falsebb);
    <D.51738>:
    <D.51732>:
    D.51163 = cfg->cbb;
    D.51163->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51744>;
    <D.51724>:
    D.51163 = cfg->cbb;
    D.51163->extended = 1;
    <D.51744>:
    <D.51716>:
  }
  D.51745 = true_bb->cil_code;
  if (D.51745 != 0B) goto <D.51746>; else goto <D.51747>;
  <D.51746>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51745 = true_bb->cil_code;
  D.51748 = (long int) D.51745;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51749 = D.51748 - D.51186;
  D.51750 = (long unsigned int) D.51749;
  D.51751 = D.51750 * 8;
  D.51752 = D.51183 + D.51751;
  *D.51752 = true_bb;
  <D.51747>:
  D.51191 = cfg->real_offset;
  true_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51756>; else goto <D.51753>;
  <D.51756>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51754>; else goto <D.51757>;
  <D.51757>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51754>; else goto <D.51758>;
  <D.51758>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51754>; else goto <D.51753>;
  <D.51754>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51759>; else goto <D.51753>;
  <D.51759>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = true_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, true_bb);
  goto <D.51755>;
  <D.51753>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51760>; else goto <D.51762>;
  <D.51762>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51763>; else goto <D.51761>;
  <D.51763>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51764>; else goto <D.51761>;
  <D.51764>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51765>; else goto <D.51761>;
  <D.51765>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51766>; else goto <D.51761>;
  <D.51766>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51760>; else goto <D.51761>;
  <D.51760>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, true_bb);
  <D.51761>:
  <D.51755>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = true_bb;
  cfg->cbb = true_bb;
  {
    struct MonoInst * inst;

    D.51141 = cfg->mempool;
    inst = mono_mempool_alloc (D.51141, 80);
    inst->data.op[1].const_val = 0;
    D.51767 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51767;
    inst->prev = 0B;
    D.51768 = inst->prev;
    inst->next = D.51768;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51769 = inst->sreg3;
    inst->sreg2 = D.51769;
    D.51770 = inst->sreg2;
    inst->sreg1 = D.51770;
    D.51162 = cfg->ip;
    inst->cil_code = D.51162;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    if (D.51164 != 0B) goto <D.51771>; else goto <D.51772>;
    <D.51771>:
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    D.51164->next = inst;
    D.51163 = cfg->cbb;
    D.51164 = D.51163->last_ins;
    inst->prev = D.51164;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    goto <D.51773>;
    <D.51772>:
    D.51163 = cfg->cbb;
    D.51163 = cfg->cbb;
    D.51163->last_ins = inst;
    D.51164 = D.51163->last_ins;
    D.51163->code = D.51164;
    <D.51773>:
  }
  D.51774 = end_bb->cil_code;
  if (D.51774 != 0B) goto <D.51775>; else goto <D.51776>;
  <D.51775>:
  D.51183 = cfg->cil_offset_to_bb;
  D.51774 = end_bb->cil_code;
  D.51777 = (long int) D.51774;
  D.51185 = cfg->cil_start;
  D.51186 = (long int) D.51185;
  D.51778 = D.51777 - D.51186;
  D.51779 = (long unsigned int) D.51778;
  D.51780 = D.51779 * 8;
  D.51781 = D.51183 + D.51780;
  *D.51781 = end_bb;
  <D.51776>:
  D.51191 = cfg->real_offset;
  end_bb->real_offset = D.51191;
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 != 0B) goto <D.51785>; else goto <D.51782>;
  <D.51785>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 <= 9) goto <D.51783>; else goto <D.51786>;
  <D.51786>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 <= 9) goto <D.51783>; else goto <D.51787>;
  <D.51787>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 <= 9) goto <D.51783>; else goto <D.51782>;
  <D.51783>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  D.51204 = *D.51203;
  if (D.51204 == 0B) goto <D.51788>; else goto <D.51782>;
  <D.51788>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51202 = D.51164->data.op[1].many_blocks;
  D.51203 = D.51202 + 8;
  *D.51203 = end_bb;
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, end_bb);
  goto <D.51784>;
  <D.51782>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  if (D.51164 == 0B) goto <D.51789>; else goto <D.51791>;
  <D.51791>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 442) goto <D.51792>; else goto <D.51790>;
  <D.51792>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  if (D.51196 != 759) goto <D.51793>; else goto <D.51790>;
  <D.51793>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51197 = D.51196 + 64985;
  if (D.51197 > 9) goto <D.51794>; else goto <D.51790>;
  <D.51794>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51199 = D.51196 + 64878;
  if (D.51199 > 9) goto <D.51795>; else goto <D.51790>;
  <D.51795>:
  D.51163 = cfg->cbb;
  D.51164 = D.51163->last_ins;
  D.51196 = D.51164->opcode;
  D.51201 = D.51196 + 64888;
  if (D.51201 > 9) goto <D.51789>; else goto <D.51790>;
  <D.51789>:
  D.51163 = cfg->cbb;
  mono_link_bblock (cfg, D.51163, end_bb);
  <D.51790>:
  <D.51784>:
  D.51163 = cfg->cbb;
  D.51163->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.51141 = cfg->mempool;
  ins = mono_mempool_alloc (D.51141, 80);
  ins->data.op[1].const_val = 0;
  D.51796 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51796;
  ins->prev = 0B;
  D.51797 = ins->prev;
  ins->next = D.51797;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51798 = ins->sreg3;
  ins->sreg2 = D.51798;
  D.51799 = ins->sreg2;
  ins->sreg1 = D.51799;
  D.51162 = cfg->ip;
  ins->cil_code = D.51162;
  ins->dreg = dreg;
  ins->type = 1;
  D.51800 = ins;
  return D.51800;
}


handle_ccastclass (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src)
{
  unsigned int D.51802;
  unsigned int D.51803;
  unsigned int D.51804;
  struct MonoMemPool * D.51805;
  unsigned int D.51806;
  unsigned int D.51807;
  unsigned int D.51808;
  int D.51809;
  unsigned int D.51810;
  unsigned int D.51811;
  int D.51812;
  long int D.51813;
  struct MonoInst * D.51814;
  int D.51815;
  int D.51816;
  const unsigned char * D.51817;
  struct MonoBasicBlock * D.51818;
  struct MonoInst * D.51819;
  long int D.51823;
  struct MonoInst * D.51824;
  int D.51825;
  int D.51826;
  unsigned int D.51829;
  unsigned int D.51830;
  int D.51831;
  unsigned char * D.51835;
  struct MonoBasicBlock * * D.51838;
  long int D.51839;
  unsigned char * D.51840;
  long int D.51841;
  long int D.51842;
  long unsigned int D.51843;
  long unsigned int D.51844;
  struct MonoBasicBlock * * D.51845;
  unsigned int D.51846;
  short unsigned int D.51851;
  short unsigned int D.51852;
  short unsigned int D.51854;
  short unsigned int D.51856;
  struct MonoBasicBlock * * D.51857;
  struct MonoBasicBlock * * D.51858;
  struct MonoBasicBlock * D.51859;
  void * D.51869;
  struct MonoBasicBlock * * D.51870;
  struct MonoBasicBlock * * D.51871;
  long unsigned int D.51875;
  long unsigned int D.51876;
  unsigned int D.51879;
  unsigned int D.51880;
  int D.51881;
  unsigned int D.51899;
  unsigned int D.51900;
  unsigned int D.51903;
  unsigned int D.51904;
  int D.51905;
  long int D.51906;
  struct MonoInst * D.51907;
  int D.51908;
  int D.51909;
  unsigned char * D.51913;
  long int D.51916;
  long int D.51917;
  long unsigned int D.51918;
  long unsigned int D.51919;
  struct MonoBasicBlock * * D.51920;
  long int D.51935;
  struct MonoInst * D.51936;
  int D.51937;
  int D.51938;
  struct MonoClass * D.51942;
  unsigned int D.51943;
  long int D.51944;
  struct MonoInst * D.51945;
  int D.51946;
  int D.51947;
  long int D.51951;
  struct MonoInst * D.51952;
  int D.51953;
  int D.51954;
  long int D.51958;
  struct MonoInst * D.51959;
  int D.51960;
  int D.51961;
  long int D.51965;
  struct MonoInst * D.51966;
  int D.51967;
  int D.51968;
  long int D.51972;
  struct MonoInst * D.51973;
  int D.51974;
  int D.51975;
  unsigned int D.51978;
  unsigned int D.51979;
  int D.51980;
  unsigned char * D.51984;
  long int D.51987;
  long int D.51988;
  long unsigned int D.51989;
  long unsigned int D.51990;
  struct MonoBasicBlock * * D.51991;
  void * D.52007;
  struct MonoBasicBlock * * D.52008;
  struct MonoBasicBlock * * D.52009;
  unsigned int D.52015;
  unsigned int D.52016;
  int D.52017;
  unsigned int D.52036;
  unsigned int D.52037;
  int D.52038;
  long int D.52039;
  struct MonoInst * D.52040;
  int D.52041;
  int D.52042;
  long int D.52046;
  struct MonoInst * D.52047;
  int D.52048;
  int D.52049;
  unsigned int D.52053;
  long int D.52054;
  struct MonoInst * D.52055;
  int D.52056;
  int D.52057;
  long int D.52061;
  struct MonoInst * D.52062;
  int D.52063;
  int D.52064;
  unsigned int D.52068;
  long int D.52069;
  struct MonoInst * D.52070;
  int D.52071;
  int D.52072;
  long int D.52076;
  struct MonoInst * D.52077;
  int D.52078;
  int D.52079;
  long int D.52083;
  struct MonoInst * D.52084;
  int D.52085;
  int D.52086;
  unsigned int D.52089;
  unsigned int D.52090;
  int D.52091;
  unsigned char * D.52095;
  long int D.52098;
  long int D.52099;
  long unsigned int D.52100;
  long unsigned int D.52101;
  struct MonoBasicBlock * * D.52102;
  void * D.52118;
  struct MonoBasicBlock * * D.52119;
  struct MonoBasicBlock * * D.52120;
  unsigned int D.52126;
  unsigned int D.52127;
  int D.52128;
  unsigned int D.52146;
  unsigned int D.52147;
  int D.52148;
  unsigned char * D.52149;
  long int D.52152;
  long int D.52153;
  long unsigned int D.52154;
  long unsigned int D.52155;
  struct MonoBasicBlock * * D.52156;
  long int D.52171;
  struct MonoInst * D.52172;
  int D.52173;
  int D.52174;
  long int D.52178;
  struct MonoInst * D.52179;
  int D.52180;
  int D.52181;
  unsigned int D.52184;
  unsigned int D.52185;
  int D.52186;
  unsigned char * D.52190;
  long int D.52193;
  long int D.52194;
  long unsigned int D.52195;
  long unsigned int D.52196;
  struct MonoBasicBlock * * D.52197;
  void * D.52213;
  struct MonoBasicBlock * * D.52214;
  struct MonoBasicBlock * * D.52215;
  unsigned int D.52221;
  unsigned int D.52222;
  int D.52223;
  unsigned char * D.52241;
  long int D.52244;
  long int D.52245;
  long unsigned int D.52246;
  long unsigned int D.52247;
  struct MonoBasicBlock * * D.52248;
  unsigned char * D.52263;
  long int D.52266;
  long int D.52267;
  long unsigned int D.52268;
  long unsigned int D.52269;
  struct MonoBasicBlock * * D.52270;
  long int D.52285;
  struct MonoInst * D.52286;
  int D.52287;
  int D.52288;
  unsigned char * D.52292;
  long int D.52295;
  long int D.52296;
  long unsigned int D.52297;
  long unsigned int D.52298;
  struct MonoBasicBlock * * D.52299;
  long int D.52314;
  struct MonoInst * D.52315;
  int D.52316;
  int D.52317;
  struct MonoInst * D.52318;
  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.51802 = alloc_ireg (cfg);
  dreg = (int) D.51802;
  D.51803 = alloc_preg (cfg);
  tmp_reg = (int) D.51803;
  D.51804 = alloc_preg (cfg);
  klass_reg = (int) D.51804;
  D.51805 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.51805, 296);
  D.51806 = cfg->num_bblocks;
  D.51807 = D.51806;
  D.51808 = D.51807 + 1;
  cfg->num_bblocks = D.51808;
  D.51809 = (int) D.51807;
  end_bb->block_num = D.51809;
  D.51805 = cfg->mempool;
  ok_result_bb = mono_mempool_alloc0 (D.51805, 296);
  D.51806 = cfg->num_bblocks;
  D.51810 = D.51806;
  D.51811 = D.51810 + 1;
  cfg->num_bblocks = D.51811;
  D.51812 = (int) D.51810;
  ok_result_bb->block_num = D.51812;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51813 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51813;
    inst->prev = 0B;
    D.51814 = inst->prev;
    inst->next = D.51814;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51815 = inst->sreg3;
    inst->sreg2 = D.51815;
    D.51816 = inst->sreg2;
    inst->sreg1 = D.51816;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51820>; else goto <D.51821>;
    <D.51820>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51822>;
    <D.51821>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51822>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51805 = cfg->mempool;
    ins = mono_mempool_alloc (D.51805, 80);
    ins->data.op[1].const_val = 0;
    D.51823 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51823;
    ins->prev = 0B;
    D.51824 = ins->prev;
    ins->next = D.51824;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51825 = ins->sreg3;
    ins->sreg2 = D.51825;
    D.51826 = ins->sreg2;
    ins->sreg1 = D.51826;
    D.51817 = cfg->ip;
    ins->cil_code = D.51817;
    if (0 != 0) goto <D.51827>; else goto <D.51828>;
    <D.51827>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.51829 = D.51806;
    D.51830 = D.51829 + 1;
    cfg->num_bblocks = D.51830;
    D.51831 = (int) D.51829;
    falsebb->block_num = D.51831;
    ins->data.op[0].target_block = ok_result_bb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, ok_result_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51832>; else goto <D.51833>;
    <D.51832>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.51834>;
    <D.51833>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51834>:
    D.51835 = falsebb->cil_code;
    if (D.51835 != 0B) goto <D.51836>; else goto <D.51837>;
    <D.51836>:
    D.51838 = cfg->cil_offset_to_bb;
    D.51835 = falsebb->cil_code;
    D.51839 = (long int) D.51835;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.51842 = D.51839 - D.51841;
    D.51843 = (long unsigned int) D.51842;
    D.51844 = D.51843 * 8;
    D.51845 = D.51838 + D.51844;
    *D.51845 = falsebb;
    <D.51837>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51850>; else goto <D.51847>;
    <D.51850>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.51848>; else goto <D.51853>;
    <D.51853>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.51848>; else goto <D.51855>;
    <D.51855>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.51848>; else goto <D.51847>;
    <D.51848>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.51860>; else goto <D.51847>;
    <D.51860>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.51849>;
    <D.51847>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.51861>; else goto <D.51863>;
    <D.51863>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.51864>; else goto <D.51862>;
    <D.51864>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.51865>; else goto <D.51862>;
    <D.51865>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.51866>; else goto <D.51862>;
    <D.51866>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.51867>; else goto <D.51862>;
    <D.51867>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.51861>; else goto <D.51862>;
    <D.51861>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.51862>:
    <D.51849>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51868>;
    <D.51828>:
    D.51805 = cfg->mempool;
    D.51869 = mono_mempool_alloc (D.51805, 16);
    ins->data.op[1].many_blocks = D.51869;
    D.51870 = ins->data.op[1].many_blocks;
    *D.51870 = ok_result_bb;
    D.51870 = ins->data.op[1].many_blocks;
    D.51871 = D.51870 + 8;
    *D.51871 = 0B;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, ok_result_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51872>; else goto <D.51873>;
    <D.51872>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.51874>;
    <D.51873>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51874>:
    D.51875 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51876 = D.51875 & 34359738368;
    if (D.51876 == 0) goto <D.51877>; else goto <D.51878>;
    <D.51877>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.51879 = D.51806;
    D.51880 = D.51879 + 1;
    cfg->num_bblocks = D.51880;
    D.51881 = (int) D.51879;
    falsebb->block_num = D.51881;
    D.51870 = ins->data.op[1].many_blocks;
    D.51871 = D.51870 + 8;
    *D.51871 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    D.51835 = falsebb->cil_code;
    if (D.51835 != 0B) goto <D.51882>; else goto <D.51883>;
    <D.51882>:
    D.51838 = cfg->cil_offset_to_bb;
    D.51835 = falsebb->cil_code;
    D.51839 = (long int) D.51835;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.51842 = D.51839 - D.51841;
    D.51843 = (long unsigned int) D.51842;
    D.51844 = D.51843 * 8;
    D.51845 = D.51838 + D.51844;
    *D.51845 = falsebb;
    <D.51883>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51887>; else goto <D.51884>;
    <D.51887>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.51885>; else goto <D.51888>;
    <D.51888>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.51885>; else goto <D.51889>;
    <D.51889>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.51885>; else goto <D.51884>;
    <D.51885>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.51890>; else goto <D.51884>;
    <D.51890>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.51886>;
    <D.51884>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.51891>; else goto <D.51893>;
    <D.51893>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.51894>; else goto <D.51892>;
    <D.51894>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.51895>; else goto <D.51892>;
    <D.51895>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.51896>; else goto <D.51892>;
    <D.51896>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.51897>; else goto <D.51892>;
    <D.51897>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.51891>; else goto <D.51892>;
    <D.51891>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.51892>:
    <D.51886>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.51898>;
    <D.51878>:
    D.51818 = cfg->cbb;
    D.51818->extended = 1;
    <D.51898>:
    <D.51868>:
  }
  save_cast_details (cfg, klass, obj_reg, 0, 0B);
  D.51899 = klass->flags;
  D.51900 = D.51899 & 32;
  if (D.51900 != 0) goto <D.51901>; else goto <D.51902>;
  <D.51901>:
  D.51805 = cfg->mempool;
  interface_fail_bb = mono_mempool_alloc0 (D.51805, 296);
  D.51806 = cfg->num_bblocks;
  D.51903 = D.51806;
  D.51904 = D.51903 + 1;
  cfg->num_bblocks = D.51904;
  D.51905 = (int) D.51903;
  interface_fail_bb->block_num = D.51905;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51906 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51906;
    inst->prev = 0B;
    D.51907 = inst->prev;
    inst->next = D.51907;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51908 = inst->sreg3;
    inst->sreg2 = D.51908;
    D.51909 = inst->sreg2;
    inst->sreg1 = D.51909;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51910>; else goto <D.51911>;
    <D.51910>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51912>;
    <D.51911>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51912>:
  }
  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, ok_result_bb);
  D.51913 = interface_fail_bb->cil_code;
  if (D.51913 != 0B) goto <D.51914>; else goto <D.51915>;
  <D.51914>:
  D.51838 = cfg->cil_offset_to_bb;
  D.51913 = interface_fail_bb->cil_code;
  D.51916 = (long int) D.51913;
  D.51840 = cfg->cil_start;
  D.51841 = (long int) D.51840;
  D.51917 = D.51916 - D.51841;
  D.51918 = (long unsigned int) D.51917;
  D.51919 = D.51918 * 8;
  D.51920 = D.51838 + D.51919;
  *D.51920 = interface_fail_bb;
  <D.51915>:
  D.51846 = cfg->real_offset;
  interface_fail_bb->real_offset = D.51846;
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 != 0B) goto <D.51924>; else goto <D.51921>;
  <D.51924>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 <= 9) goto <D.51922>; else goto <D.51925>;
  <D.51925>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 <= 9) goto <D.51922>; else goto <D.51926>;
  <D.51926>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 <= 9) goto <D.51922>; else goto <D.51921>;
  <D.51922>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  D.51859 = *D.51858;
  if (D.51859 == 0B) goto <D.51927>; else goto <D.51921>;
  <D.51927>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  *D.51858 = interface_fail_bb;
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, interface_fail_bb);
  goto <D.51923>;
  <D.51921>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 == 0B) goto <D.51928>; else goto <D.51930>;
  <D.51930>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 442) goto <D.51931>; else goto <D.51929>;
  <D.51931>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 759) goto <D.51932>; else goto <D.51929>;
  <D.51932>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 > 9) goto <D.51933>; else goto <D.51929>;
  <D.51933>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 > 9) goto <D.51934>; else goto <D.51929>;
  <D.51934>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 > 9) goto <D.51928>; else goto <D.51929>;
  <D.51928>:
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, interface_fail_bb);
  <D.51929>:
  <D.51923>:
  D.51818 = cfg->cbb;
  D.51818->next_bb = interface_fail_bb;
  cfg->cbb = interface_fail_bb;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51935 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51935;
    inst->prev = 0B;
    D.51936 = inst->prev;
    inst->next = D.51936;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51937 = inst->sreg3;
    inst->sreg2 = D.51937;
    D.51938 = inst->sreg2;
    inst->sreg1 = D.51938;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51939>; else goto <D.51940>;
    <D.51939>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51941>;
    <D.51940>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51941>:
  }
  D.51942 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check (cfg, klass_reg, D.51942);
  D.51943 = alloc_preg (cfg);
  tmp_reg = (int) D.51943;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51944 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51944;
    inst->prev = 0B;
    D.51945 = inst->prev;
    inst->next = D.51945;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51946 = inst->sreg3;
    inst->sreg2 = D.51946;
    D.51947 = inst->sreg2;
    inst->sreg1 = D.51947;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51948>; else goto <D.51949>;
    <D.51948>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51950>;
    <D.51949>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51950>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51951 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51951;
    inst->prev = 0B;
    D.51952 = inst->prev;
    inst->next = D.51952;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51953 = inst->sreg3;
    inst->sreg2 = D.51953;
    D.51954 = inst->sreg2;
    inst->sreg1 = D.51954;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51955>; else goto <D.51956>;
    <D.51955>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51957>;
    <D.51956>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51957>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51958 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51958;
    inst->prev = 0B;
    D.51959 = inst->prev;
    inst->next = D.51959;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51960 = inst->sreg3;
    inst->sreg2 = D.51960;
    D.51961 = inst->sreg2;
    inst->sreg1 = D.51961;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->data.op[1].p = "InvalidCastException";
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51962>; else goto <D.51963>;
    <D.51962>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51964>;
    <D.51963>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51964>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.51965 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51965;
    inst->prev = 0B;
    D.51966 = inst->prev;
    inst->next = D.51966;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51967 = inst->sreg3;
    inst->sreg2 = D.51967;
    D.51968 = inst->sreg2;
    inst->sreg1 = D.51968;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51969>; else goto <D.51970>;
    <D.51969>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.51971>;
    <D.51970>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51971>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51805 = cfg->mempool;
    ins = mono_mempool_alloc (D.51805, 80);
    ins->data.op[1].const_val = 0;
    D.51972 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.51972;
    ins->prev = 0B;
    D.51973 = ins->prev;
    ins->next = D.51973;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.51974 = ins->sreg3;
    ins->sreg2 = D.51974;
    D.51975 = ins->sreg2;
    ins->sreg1 = D.51975;
    D.51817 = cfg->ip;
    ins->cil_code = D.51817;
    if (1 != 0) goto <D.51976>; else goto <D.51977>;
    <D.51976>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.51978 = D.51806;
    D.51979 = D.51978 + 1;
    cfg->num_bblocks = D.51979;
    D.51980 = (int) D.51978;
    falsebb->block_num = D.51980;
    ins->data.op[0].target_block = end_bb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, end_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51981>; else goto <D.51982>;
    <D.51981>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.51983>;
    <D.51982>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.51983>:
    D.51984 = falsebb->cil_code;
    if (D.51984 != 0B) goto <D.51985>; else goto <D.51986>;
    <D.51985>:
    D.51838 = cfg->cil_offset_to_bb;
    D.51984 = falsebb->cil_code;
    D.51987 = (long int) D.51984;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.51988 = D.51987 - D.51841;
    D.51989 = (long unsigned int) D.51988;
    D.51990 = D.51989 * 8;
    D.51991 = D.51838 + D.51990;
    *D.51991 = falsebb;
    <D.51986>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.51995>; else goto <D.51992>;
    <D.51995>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.51993>; else goto <D.51996>;
    <D.51996>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.51993>; else goto <D.51997>;
    <D.51997>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.51993>; else goto <D.51992>;
    <D.51993>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.51998>; else goto <D.51992>;
    <D.51998>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.51994>;
    <D.51992>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.51999>; else goto <D.52001>;
    <D.52001>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52002>; else goto <D.52000>;
    <D.52002>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52003>; else goto <D.52000>;
    <D.52003>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52004>; else goto <D.52000>;
    <D.52004>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52005>; else goto <D.52000>;
    <D.52005>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.51999>; else goto <D.52000>;
    <D.51999>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52000>:
    <D.51994>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52006>;
    <D.51977>:
    D.51805 = cfg->mempool;
    D.52007 = mono_mempool_alloc (D.51805, 16);
    ins->data.op[1].many_blocks = D.52007;
    D.52008 = ins->data.op[1].many_blocks;
    *D.52008 = end_bb;
    D.52008 = ins->data.op[1].many_blocks;
    D.52009 = D.52008 + 8;
    *D.52009 = 0B;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, end_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52010>; else goto <D.52011>;
    <D.52010>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.52012>;
    <D.52011>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52012>:
    D.51875 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51876 = D.51875 & 34359738368;
    if (D.51876 == 0) goto <D.52013>; else goto <D.52014>;
    <D.52013>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.52015 = D.51806;
    D.52016 = D.52015 + 1;
    cfg->num_bblocks = D.52016;
    D.52017 = (int) D.52015;
    falsebb->block_num = D.52017;
    D.52008 = ins->data.op[1].many_blocks;
    D.52009 = D.52008 + 8;
    *D.52009 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    D.51984 = falsebb->cil_code;
    if (D.51984 != 0B) goto <D.52018>; else goto <D.52019>;
    <D.52018>:
    D.51838 = cfg->cil_offset_to_bb;
    D.51984 = falsebb->cil_code;
    D.51987 = (long int) D.51984;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.51988 = D.51987 - D.51841;
    D.51989 = (long unsigned int) D.51988;
    D.51990 = D.51989 * 8;
    D.51991 = D.51838 + D.51990;
    *D.51991 = falsebb;
    <D.52019>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52023>; else goto <D.52020>;
    <D.52023>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.52021>; else goto <D.52024>;
    <D.52024>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.52021>; else goto <D.52025>;
    <D.52025>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.52021>; else goto <D.52020>;
    <D.52021>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.52026>; else goto <D.52020>;
    <D.52026>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.52022>;
    <D.52020>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.52027>; else goto <D.52029>;
    <D.52029>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52030>; else goto <D.52028>;
    <D.52030>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52031>; else goto <D.52028>;
    <D.52031>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52032>; else goto <D.52028>;
    <D.52032>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52033>; else goto <D.52028>;
    <D.52033>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.52027>; else goto <D.52028>;
    <D.52027>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52028>:
    <D.52022>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52034>;
    <D.52014>:
    D.51818 = cfg->cbb;
    D.51818->extended = 1;
    <D.52034>:
    <D.52006>:
  }
  goto <D.52035>;
  <D.51902>:
  D.51805 = cfg->mempool;
  no_proxy_bb = mono_mempool_alloc0 (D.51805, 296);
  D.51806 = cfg->num_bblocks;
  D.52036 = D.51806;
  D.52037 = D.52036 + 1;
  cfg->num_bblocks = D.52037;
  D.52038 = (int) D.52036;
  no_proxy_bb->block_num = D.52038;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52039 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52039;
    inst->prev = 0B;
    D.52040 = inst->prev;
    inst->next = D.52040;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52041 = inst->sreg3;
    inst->sreg2 = D.52041;
    D.52042 = inst->sreg2;
    inst->sreg1 = D.52042;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52043>; else goto <D.52044>;
    <D.52043>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52045>;
    <D.52044>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52045>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52046 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52046;
    inst->prev = 0B;
    D.52047 = inst->prev;
    inst->next = D.52047;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52048 = inst->sreg3;
    inst->sreg2 = D.52048;
    D.52049 = inst->sreg2;
    inst->sreg1 = D.52049;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52050>; else goto <D.52051>;
    <D.52050>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52052>;
    <D.52051>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52052>:
  }
  D.51942 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.51942, 556, no_proxy_bb);
  D.52053 = alloc_preg (cfg);
  tmp_reg = (int) D.52053;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52054 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52054;
    inst->prev = 0B;
    D.52055 = inst->prev;
    inst->next = D.52055;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52056 = inst->sreg3;
    inst->sreg2 = D.52056;
    D.52057 = inst->sreg2;
    inst->sreg1 = D.52057;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 24;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52058>; else goto <D.52059>;
    <D.52058>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52060>;
    <D.52059>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52060>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52061 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52061;
    inst->prev = 0B;
    D.52062 = inst->prev;
    inst->next = D.52062;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52063 = inst->sreg3;
    inst->sreg2 = D.52063;
    D.52064 = inst->sreg2;
    inst->sreg1 = D.52064;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 16;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52065>; else goto <D.52066>;
    <D.52065>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52067>;
    <D.52066>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52067>:
  }
  D.52068 = alloc_preg (cfg);
  tmp_reg = (int) D.52068;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52069 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52069;
    inst->prev = 0B;
    D.52070 = inst->prev;
    inst->next = D.52070;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52071 = inst->sreg3;
    inst->sreg2 = D.52071;
    D.52072 = inst->sreg2;
    inst->sreg1 = D.52072;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52073>; else goto <D.52074>;
    <D.52073>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52075>;
    <D.52074>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52075>:
  }
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52076 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52076;
    inst->prev = 0B;
    D.52077 = inst->prev;
    inst->next = D.52077;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52078 = inst->sreg3;
    inst->sreg2 = D.52078;
    D.52079 = inst->sreg2;
    inst->sreg1 = D.52079;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52080>; else goto <D.52081>;
    <D.52080>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52082>;
    <D.52081>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52082>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51805 = cfg->mempool;
    ins = mono_mempool_alloc (D.51805, 80);
    ins->data.op[1].const_val = 0;
    D.52083 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.52083;
    ins->prev = 0B;
    D.52084 = ins->prev;
    ins->next = D.52084;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.52085 = ins->sreg3;
    ins->sreg2 = D.52085;
    D.52086 = ins->sreg2;
    ins->sreg1 = D.52086;
    D.51817 = cfg->ip;
    ins->cil_code = D.51817;
    if (0 != 0) goto <D.52087>; else goto <D.52088>;
    <D.52087>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.52089 = D.51806;
    D.52090 = D.52089 + 1;
    cfg->num_bblocks = D.52090;
    D.52091 = (int) D.52089;
    falsebb->block_num = D.52091;
    ins->data.op[0].target_block = no_proxy_bb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, no_proxy_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52092>; else goto <D.52093>;
    <D.52092>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.52094>;
    <D.52093>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52094>:
    D.52095 = falsebb->cil_code;
    if (D.52095 != 0B) goto <D.52096>; else goto <D.52097>;
    <D.52096>:
    D.51838 = cfg->cil_offset_to_bb;
    D.52095 = falsebb->cil_code;
    D.52098 = (long int) D.52095;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.52099 = D.52098 - D.51841;
    D.52100 = (long unsigned int) D.52099;
    D.52101 = D.52100 * 8;
    D.52102 = D.51838 + D.52101;
    *D.52102 = falsebb;
    <D.52097>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52106>; else goto <D.52103>;
    <D.52106>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.52104>; else goto <D.52107>;
    <D.52107>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.52104>; else goto <D.52108>;
    <D.52108>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.52104>; else goto <D.52103>;
    <D.52104>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.52109>; else goto <D.52103>;
    <D.52109>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.52105>;
    <D.52103>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.52110>; else goto <D.52112>;
    <D.52112>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52113>; else goto <D.52111>;
    <D.52113>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52114>; else goto <D.52111>;
    <D.52114>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52115>; else goto <D.52111>;
    <D.52115>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52116>; else goto <D.52111>;
    <D.52116>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.52110>; else goto <D.52111>;
    <D.52110>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52111>:
    <D.52105>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52117>;
    <D.52088>:
    D.51805 = cfg->mempool;
    D.52118 = mono_mempool_alloc (D.51805, 16);
    ins->data.op[1].many_blocks = D.52118;
    D.52119 = ins->data.op[1].many_blocks;
    *D.52119 = no_proxy_bb;
    D.52119 = ins->data.op[1].many_blocks;
    D.52120 = D.52119 + 8;
    *D.52120 = 0B;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, no_proxy_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52121>; else goto <D.52122>;
    <D.52121>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.52123>;
    <D.52122>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52123>:
    D.51875 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51876 = D.51875 & 34359738368;
    if (D.51876 == 0) goto <D.52124>; else goto <D.52125>;
    <D.52124>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.52126 = D.51806;
    D.52127 = D.52126 + 1;
    cfg->num_bblocks = D.52127;
    D.52128 = (int) D.52126;
    falsebb->block_num = D.52128;
    D.52119 = ins->data.op[1].many_blocks;
    D.52120 = D.52119 + 8;
    *D.52120 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    D.52095 = falsebb->cil_code;
    if (D.52095 != 0B) goto <D.52129>; else goto <D.52130>;
    <D.52129>:
    D.51838 = cfg->cil_offset_to_bb;
    D.52095 = falsebb->cil_code;
    D.52098 = (long int) D.52095;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.52099 = D.52098 - D.51841;
    D.52100 = (long unsigned int) D.52099;
    D.52101 = D.52100 * 8;
    D.52102 = D.51838 + D.52101;
    *D.52102 = falsebb;
    <D.52130>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52134>; else goto <D.52131>;
    <D.52134>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.52132>; else goto <D.52135>;
    <D.52135>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.52132>; else goto <D.52136>;
    <D.52136>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.52132>; else goto <D.52131>;
    <D.52132>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.52137>; else goto <D.52131>;
    <D.52137>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.52133>;
    <D.52131>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.52138>; else goto <D.52140>;
    <D.52140>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52141>; else goto <D.52139>;
    <D.52141>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52142>; else goto <D.52139>;
    <D.52142>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52143>; else goto <D.52139>;
    <D.52143>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52144>; else goto <D.52139>;
    <D.52144>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.52138>; else goto <D.52139>;
    <D.52138>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52139>:
    <D.52133>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52145>;
    <D.52125>:
    D.51818 = cfg->cbb;
    D.51818->extended = 1;
    <D.52145>:
    <D.52117>:
  }
  D.51805 = cfg->mempool;
  fail_1_bb = mono_mempool_alloc0 (D.51805, 296);
  D.51806 = cfg->num_bblocks;
  D.52146 = D.51806;
  D.52147 = D.52146 + 1;
  cfg->num_bblocks = D.52147;
  D.52148 = (int) D.52146;
  fail_1_bb->block_num = D.52148;
  mini_emit_isninst_cast (cfg, klass_reg, klass, fail_1_bb, ok_result_bb);
  D.52149 = fail_1_bb->cil_code;
  if (D.52149 != 0B) goto <D.52150>; else goto <D.52151>;
  <D.52150>:
  D.51838 = cfg->cil_offset_to_bb;
  D.52149 = fail_1_bb->cil_code;
  D.52152 = (long int) D.52149;
  D.51840 = cfg->cil_start;
  D.51841 = (long int) D.51840;
  D.52153 = D.52152 - D.51841;
  D.52154 = (long unsigned int) D.52153;
  D.52155 = D.52154 * 8;
  D.52156 = D.51838 + D.52155;
  *D.52156 = fail_1_bb;
  <D.52151>:
  D.51846 = cfg->real_offset;
  fail_1_bb->real_offset = D.51846;
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 != 0B) goto <D.52160>; else goto <D.52157>;
  <D.52160>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 <= 9) goto <D.52158>; else goto <D.52161>;
  <D.52161>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 <= 9) goto <D.52158>; else goto <D.52162>;
  <D.52162>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 <= 9) goto <D.52158>; else goto <D.52157>;
  <D.52158>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  D.51859 = *D.51858;
  if (D.51859 == 0B) goto <D.52163>; else goto <D.52157>;
  <D.52163>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  *D.51858 = fail_1_bb;
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, fail_1_bb);
  goto <D.52159>;
  <D.52157>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 == 0B) goto <D.52164>; else goto <D.52166>;
  <D.52166>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 442) goto <D.52167>; else goto <D.52165>;
  <D.52167>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 759) goto <D.52168>; else goto <D.52165>;
  <D.52168>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 > 9) goto <D.52169>; else goto <D.52165>;
  <D.52169>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 > 9) goto <D.52170>; else goto <D.52165>;
  <D.52170>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 > 9) goto <D.52164>; else goto <D.52165>;
  <D.52164>:
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, fail_1_bb);
  <D.52165>:
  <D.52159>:
  D.51818 = cfg->cbb;
  D.51818->next_bb = fail_1_bb;
  cfg->cbb = fail_1_bb;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52171 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52171;
    inst->prev = 0B;
    D.52172 = inst->prev;
    inst->next = D.52172;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52173 = inst->sreg3;
    inst->sreg2 = D.52173;
    D.52174 = inst->sreg2;
    inst->sreg1 = D.52174;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52175>; else goto <D.52176>;
    <D.52175>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52177>;
    <D.52176>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52177>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.51805 = cfg->mempool;
    ins = mono_mempool_alloc (D.51805, 80);
    ins->data.op[1].const_val = 0;
    D.52178 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.52178;
    ins->prev = 0B;
    D.52179 = ins->prev;
    ins->next = D.52179;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.52180 = ins->sreg3;
    ins->sreg2 = D.52180;
    D.52181 = ins->sreg2;
    ins->sreg1 = D.52181;
    D.51817 = cfg->ip;
    ins->cil_code = D.51817;
    if (1 != 0) goto <D.52182>; else goto <D.52183>;
    <D.52182>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.52184 = D.51806;
    D.52185 = D.52184 + 1;
    cfg->num_bblocks = D.52185;
    D.52186 = (int) D.52184;
    falsebb->block_num = D.52186;
    ins->data.op[0].target_block = end_bb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, end_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52187>; else goto <D.52188>;
    <D.52187>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.52189>;
    <D.52188>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52189>:
    D.52190 = falsebb->cil_code;
    if (D.52190 != 0B) goto <D.52191>; else goto <D.52192>;
    <D.52191>:
    D.51838 = cfg->cil_offset_to_bb;
    D.52190 = falsebb->cil_code;
    D.52193 = (long int) D.52190;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.52194 = D.52193 - D.51841;
    D.52195 = (long unsigned int) D.52194;
    D.52196 = D.52195 * 8;
    D.52197 = D.51838 + D.52196;
    *D.52197 = falsebb;
    <D.52192>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52201>; else goto <D.52198>;
    <D.52201>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.52199>; else goto <D.52202>;
    <D.52202>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.52199>; else goto <D.52203>;
    <D.52203>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.52199>; else goto <D.52198>;
    <D.52199>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.52204>; else goto <D.52198>;
    <D.52204>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.52200>;
    <D.52198>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.52205>; else goto <D.52207>;
    <D.52207>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52208>; else goto <D.52206>;
    <D.52208>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52209>; else goto <D.52206>;
    <D.52209>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52210>; else goto <D.52206>;
    <D.52210>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52211>; else goto <D.52206>;
    <D.52211>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.52205>; else goto <D.52206>;
    <D.52205>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52206>:
    <D.52200>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52212>;
    <D.52183>:
    D.51805 = cfg->mempool;
    D.52213 = mono_mempool_alloc (D.51805, 16);
    ins->data.op[1].many_blocks = D.52213;
    D.52214 = ins->data.op[1].many_blocks;
    *D.52214 = end_bb;
    D.52214 = ins->data.op[1].many_blocks;
    D.52215 = D.52214 + 8;
    *D.52215 = 0B;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, end_bb);
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52216>; else goto <D.52217>;
    <D.52216>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = ins;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    ins->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    goto <D.52218>;
    <D.52217>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = ins;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52218>:
    D.51875 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.51876 = D.51875 & 34359738368;
    if (D.51876 == 0) goto <D.52219>; else goto <D.52220>;
    <D.52219>:
    D.51805 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.51805, 296);
    D.51806 = cfg->num_bblocks;
    D.52221 = D.51806;
    D.52222 = D.52221 + 1;
    cfg->num_bblocks = D.52222;
    D.52223 = (int) D.52221;
    falsebb->block_num = D.52223;
    D.52214 = ins->data.op[1].many_blocks;
    D.52215 = D.52214 + 8;
    *D.52215 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    D.52190 = falsebb->cil_code;
    if (D.52190 != 0B) goto <D.52224>; else goto <D.52225>;
    <D.52224>:
    D.51838 = cfg->cil_offset_to_bb;
    D.52190 = falsebb->cil_code;
    D.52193 = (long int) D.52190;
    D.51840 = cfg->cil_start;
    D.51841 = (long int) D.51840;
    D.52194 = D.52193 - D.51841;
    D.52195 = (long unsigned int) D.52194;
    D.52196 = D.52195 * 8;
    D.52197 = D.51838 + D.52196;
    *D.52197 = falsebb;
    <D.52225>:
    D.51846 = cfg->real_offset;
    falsebb->real_offset = D.51846;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52229>; else goto <D.52226>;
    <D.52229>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 <= 9) goto <D.52227>; else goto <D.52230>;
    <D.52230>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 <= 9) goto <D.52227>; else goto <D.52231>;
    <D.52231>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 <= 9) goto <D.52227>; else goto <D.52226>;
    <D.52227>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    D.51859 = *D.51858;
    if (D.51859 == 0B) goto <D.52232>; else goto <D.52226>;
    <D.52232>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51857 = D.51819->data.op[1].many_blocks;
    D.51858 = D.51857 + 8;
    *D.51858 = falsebb;
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    goto <D.52228>;
    <D.52226>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 == 0B) goto <D.52233>; else goto <D.52235>;
    <D.52235>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 442) goto <D.52236>; else goto <D.52234>;
    <D.52236>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    if (D.51851 != 759) goto <D.52237>; else goto <D.52234>;
    <D.52237>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51852 = D.51851 + 64985;
    if (D.51852 > 9) goto <D.52238>; else goto <D.52234>;
    <D.52238>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51854 = D.51851 + 64878;
    if (D.51854 > 9) goto <D.52239>; else goto <D.52234>;
    <D.52239>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51851 = D.51819->opcode;
    D.51856 = D.51851 + 64888;
    if (D.51856 > 9) goto <D.52233>; else goto <D.52234>;
    <D.52233>:
    D.51818 = cfg->cbb;
    mono_link_bblock (cfg, D.51818, falsebb);
    <D.52234>:
    <D.52228>:
    D.51818 = cfg->cbb;
    D.51818->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.52240>;
    <D.52220>:
    D.51818 = cfg->cbb;
    D.51818->extended = 1;
    <D.52240>:
    <D.52212>:
  }
  D.52241 = no_proxy_bb->cil_code;
  if (D.52241 != 0B) goto <D.52242>; else goto <D.52243>;
  <D.52242>:
  D.51838 = cfg->cil_offset_to_bb;
  D.52241 = no_proxy_bb->cil_code;
  D.52244 = (long int) D.52241;
  D.51840 = cfg->cil_start;
  D.51841 = (long int) D.51840;
  D.52245 = D.52244 - D.51841;
  D.52246 = (long unsigned int) D.52245;
  D.52247 = D.52246 * 8;
  D.52248 = D.51838 + D.52247;
  *D.52248 = no_proxy_bb;
  <D.52243>:
  D.51846 = cfg->real_offset;
  no_proxy_bb->real_offset = D.51846;
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 != 0B) goto <D.52252>; else goto <D.52249>;
  <D.52252>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 <= 9) goto <D.52250>; else goto <D.52253>;
  <D.52253>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 <= 9) goto <D.52250>; else goto <D.52254>;
  <D.52254>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 <= 9) goto <D.52250>; else goto <D.52249>;
  <D.52250>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  D.51859 = *D.51858;
  if (D.51859 == 0B) goto <D.52255>; else goto <D.52249>;
  <D.52255>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  *D.51858 = no_proxy_bb;
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, no_proxy_bb);
  goto <D.52251>;
  <D.52249>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 == 0B) goto <D.52256>; else goto <D.52258>;
  <D.52258>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 442) goto <D.52259>; else goto <D.52257>;
  <D.52259>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 759) goto <D.52260>; else goto <D.52257>;
  <D.52260>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 > 9) goto <D.52261>; else goto <D.52257>;
  <D.52261>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 > 9) goto <D.52262>; else goto <D.52257>;
  <D.52262>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 > 9) goto <D.52256>; else goto <D.52257>;
  <D.52256>:
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, no_proxy_bb);
  <D.52257>:
  <D.52251>:
  D.51818 = cfg->cbb;
  D.51818->next_bb = no_proxy_bb;
  cfg->cbb = no_proxy_bb;
  mini_emit_castclass (cfg, obj_reg, klass_reg, klass, ok_result_bb);
  <D.52035>:
  D.52263 = ok_result_bb->cil_code;
  if (D.52263 != 0B) goto <D.52264>; else goto <D.52265>;
  <D.52264>:
  D.51838 = cfg->cil_offset_to_bb;
  D.52263 = ok_result_bb->cil_code;
  D.52266 = (long int) D.52263;
  D.51840 = cfg->cil_start;
  D.51841 = (long int) D.51840;
  D.52267 = D.52266 - D.51841;
  D.52268 = (long unsigned int) D.52267;
  D.52269 = D.52268 * 8;
  D.52270 = D.51838 + D.52269;
  *D.52270 = ok_result_bb;
  <D.52265>:
  D.51846 = cfg->real_offset;
  ok_result_bb->real_offset = D.51846;
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 != 0B) goto <D.52274>; else goto <D.52271>;
  <D.52274>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 <= 9) goto <D.52272>; else goto <D.52275>;
  <D.52275>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 <= 9) goto <D.52272>; else goto <D.52276>;
  <D.52276>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 <= 9) goto <D.52272>; else goto <D.52271>;
  <D.52272>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  D.51859 = *D.51858;
  if (D.51859 == 0B) goto <D.52277>; else goto <D.52271>;
  <D.52277>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  *D.51858 = ok_result_bb;
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, ok_result_bb);
  goto <D.52273>;
  <D.52271>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 == 0B) goto <D.52278>; else goto <D.52280>;
  <D.52280>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 442) goto <D.52281>; else goto <D.52279>;
  <D.52281>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 759) goto <D.52282>; else goto <D.52279>;
  <D.52282>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 > 9) goto <D.52283>; else goto <D.52279>;
  <D.52283>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 > 9) goto <D.52284>; else goto <D.52279>;
  <D.52284>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 > 9) goto <D.52278>; else goto <D.52279>;
  <D.52278>:
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, ok_result_bb);
  <D.52279>:
  <D.52273>:
  D.51818 = cfg->cbb;
  D.51818->next_bb = ok_result_bb;
  cfg->cbb = ok_result_bb;
  {
    struct MonoInst * inst;

    D.51805 = cfg->mempool;
    inst = mono_mempool_alloc (D.51805, 80);
    inst->data.op[1].const_val = 0;
    D.52285 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52285;
    inst->prev = 0B;
    D.52286 = inst->prev;
    inst->next = D.52286;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52287 = inst->sreg3;
    inst->sreg2 = D.52287;
    D.52288 = inst->sreg2;
    inst->sreg1 = D.52288;
    D.51817 = cfg->ip;
    inst->cil_code = D.51817;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    if (D.51819 != 0B) goto <D.52289>; else goto <D.52290>;
    <D.52289>:
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    D.51819->next = inst;
    D.51818 = cfg->cbb;
    D.51819 = D.51818->last_ins;
    inst->prev = D.51819;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    goto <D.52291>;
    <D.52290>:
    D.51818 = cfg->cbb;
    D.51818 = cfg->cbb;
    D.51818->last_ins = inst;
    D.51819 = D.51818->last_ins;
    D.51818->code = D.51819;
    <D.52291>:
  }
  D.52292 = end_bb->cil_code;
  if (D.52292 != 0B) goto <D.52293>; else goto <D.52294>;
  <D.52293>:
  D.51838 = cfg->cil_offset_to_bb;
  D.52292 = end_bb->cil_code;
  D.52295 = (long int) D.52292;
  D.51840 = cfg->cil_start;
  D.51841 = (long int) D.51840;
  D.52296 = D.52295 - D.51841;
  D.52297 = (long unsigned int) D.52296;
  D.52298 = D.52297 * 8;
  D.52299 = D.51838 + D.52298;
  *D.52299 = end_bb;
  <D.52294>:
  D.51846 = cfg->real_offset;
  end_bb->real_offset = D.51846;
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 != 0B) goto <D.52303>; else goto <D.52300>;
  <D.52303>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 <= 9) goto <D.52301>; else goto <D.52304>;
  <D.52304>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 <= 9) goto <D.52301>; else goto <D.52305>;
  <D.52305>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 <= 9) goto <D.52301>; else goto <D.52300>;
  <D.52301>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  D.51859 = *D.51858;
  if (D.51859 == 0B) goto <D.52306>; else goto <D.52300>;
  <D.52306>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51857 = D.51819->data.op[1].many_blocks;
  D.51858 = D.51857 + 8;
  *D.51858 = end_bb;
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, end_bb);
  goto <D.52302>;
  <D.52300>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  if (D.51819 == 0B) goto <D.52307>; else goto <D.52309>;
  <D.52309>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 442) goto <D.52310>; else goto <D.52308>;
  <D.52310>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  if (D.51851 != 759) goto <D.52311>; else goto <D.52308>;
  <D.52311>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51852 = D.51851 + 64985;
  if (D.51852 > 9) goto <D.52312>; else goto <D.52308>;
  <D.52312>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51854 = D.51851 + 64878;
  if (D.51854 > 9) goto <D.52313>; else goto <D.52308>;
  <D.52313>:
  D.51818 = cfg->cbb;
  D.51819 = D.51818->last_ins;
  D.51851 = D.51819->opcode;
  D.51856 = D.51851 + 64888;
  if (D.51856 > 9) goto <D.52307>; else goto <D.52308>;
  <D.52307>:
  D.51818 = cfg->cbb;
  mono_link_bblock (cfg, D.51818, end_bb);
  <D.52308>:
  <D.52302>:
  D.51818 = cfg->cbb;
  D.51818->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.51805 = cfg->mempool;
  ins = mono_mempool_alloc (D.51805, 80);
  ins->data.op[1].const_val = 0;
  D.52314 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52314;
  ins->prev = 0B;
  D.52315 = ins->prev;
  ins->next = D.52315;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52316 = ins->sreg3;
  ins->sreg2 = D.52316;
  D.52317 = ins->sreg2;
  ins->sreg1 = D.52317;
  D.51817 = cfg->ip;
  ins->cil_code = D.51817;
  ins->dreg = dreg;
  ins->type = 1;
  D.52318 = ins;
  return D.52318;
}


emit_memory_barrier (struct MonoCompile * cfg, int kind)
{
  struct MonoMemPool * D.52320;
  long int D.52321;
  struct MonoInst * D.52322;
  int D.52323;
  int D.52324;
  const unsigned char * D.52325;
  struct MonoBasicBlock * D.52326;
  struct MonoInst * D.52327;
  struct MonoInst * D.52331;
  struct MonoInst * ins;

  ins = 0B;
  D.52320 = cfg->mempool;
  ins = mono_mempool_alloc (D.52320, 80);
  ins->data.op[1].const_val = 0;
  D.52321 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52321;
  ins->prev = 0B;
  D.52322 = ins->prev;
  ins->next = D.52322;
  ins->opcode = 813;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52323 = ins->sreg3;
  ins->sreg2 = D.52323;
  D.52324 = ins->sreg2;
  ins->sreg1 = D.52324;
  D.52325 = cfg->ip;
  ins->cil_code = D.52325;
  D.52326 = cfg->cbb;
  D.52327 = D.52326->last_ins;
  if (D.52327 != 0B) goto <D.52328>; else goto <D.52329>;
  <D.52328>:
  D.52326 = cfg->cbb;
  D.52327 = D.52326->last_ins;
  D.52327->next = ins;
  D.52326 = cfg->cbb;
  D.52327 = D.52326->last_ins;
  ins->prev = D.52327;
  D.52326 = cfg->cbb;
  D.52326->last_ins = ins;
  goto <D.52330>;
  <D.52329>:
  D.52326 = cfg->cbb;
  D.52326 = cfg->cbb;
  D.52326->last_ins = ins;
  D.52327 = D.52326->last_ins;
  D.52326->code = D.52327;
  <D.52330>:
  ins->backend.memory_barrier_kind = kind;
  D.52331 = ins;
  return D.52331;
}


type_from_op (struct MonoInst * ins, struct MonoInst * src1, struct MonoInst * src2)
{
  short unsigned int D.52333;
  int D.52334;
  unsigned char D.52335;
  int D.52336;
  unsigned char D.52337;
  int D.52338;
  char D.52339;
  unsigned char D.52340;
  int D.52341;
  short unsigned int D.52342;
  short unsigned int D.52343;
  char D.52344;
  char D.52345;
  char D.52346;
  _Bool D.52347;
  unsigned char D.52348;
  char D.52358;
  _Bool D.52359;
  unsigned char D.52360;
  short unsigned int D.52366;
  short unsigned int D.52367;
  short unsigned int D.52368;
  short unsigned int D.52369;
  int D.52370;
  int D.52371;
  _Bool D.52372;
  unsigned char D.52373;
  char D.52374;
  short unsigned int D.52375;
  short unsigned int D.52376;
  unsigned char D.52377;
  short unsigned int D.52381;
  short unsigned int D.52382;
  short unsigned int D.52384;
  short unsigned int D.52385;
  short unsigned int D.52386;
  short unsigned int D.52387;
  short unsigned int D.52389;
  short unsigned int D.52390;
  struct MonoClass * D.52395;

  D.52333 = ins->opcode;
  D.52334 = (int) D.52333;
  switch (D.52334) <default: <D.25187>, case 59: <D.25110>, case 60: <D.25111>, case 61: <D.25112>, case 62: <D.25113>, case 63: <D.25114>, case 64: <D.25115>, case 65: <D.25116>, case 66: <D.25117>, case 67: <D.25118>, case 68: <D.25119>, case 88: <D.25092>, case 89: <D.25093>, case 90: <D.25094>, case 91: <D.25095>, case 92: <D.25098>, case 93: <D.25096>, case 94: <D.25099>, case 95: <D.25100>, case 96: <D.25101>, case 97: <D.25102>, case 98: <D.25103>, case 99: <D.25104>, case 100: <D.25105>, case 101: <D.25125>, case 102: <D.25126>, case 103: <D.25127>, case 104: <D.25128>, case 105: <D.25129>, case 106: <D.25157>, case 107: <D.25163>, case 108: <D.25164>, case 109: <D.25130>, case 110: <D.25158>, case 118: <D.25131>, case 130: <D.25144>, case 131: <D.25145>, case 132: <D.25146>, case 133: <D.25162>, case 134: <D.25147>, case 135: <D.25148>, case 136: <D.25149>, case 137: <D.25161>, case 138: <D.25142>, case 139: <D.25143>, case 179: <D.25136>, case 180: <D.25137>, case 181: <D.25138>, case 182: <D.25139>, case 183: <D.25140>, case 184: <D.25141>, case 185: <D.25159>, case 186: <D.25160>, case 209: <D.25166>, case 210: <D.25167>, case 211: <D.25168>, case 212: <D.25169>, case 213: <D.25170>, case 214: <D.25171>, case 215: <D.25172>, case 216: <D.25173>, case 217: <D.25174>, case 218: <D.25175>, case 219: <D.25176>, case 224: <D.25150>, case 322: <D.25106>, case 325: <D.25107>, case 326: <D.25108>, case 327: <D.25109>, case 388: <D.25177>, case 389: <D.25178>, case 390: <D.25179>, case 391: <D.25180>, case 392: <D.25181>, case 393: <D.25182>, case 394: <D.25183>, case 395: <D.25184>, case 396: <D.25185>, case 397: <D.25186>, case 446: <D.25120>, case 447: <D.25121>, case 448: <D.25122>, case 449: <D.25123>, case 450: <D.25124>, case 728: <D.25165>>
  <D.25092>:
  <D.25093>:
  <D.25094>:
  <D.25095>:
  <D.25096>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52339 = bin_num_table[D.52336][D.52338];
  ins->type = D.52339;
  D.52333 = ins->opcode;
  D.52340 = ins->type;
  D.52341 = (int) D.52340;
  D.52342 = binops_op_map[D.52341];
  D.52343 = D.52333 + D.52342;
  ins->opcode = D.52343;
  goto <D.25097>;
  <D.25098>:
  <D.25099>:
  <D.25100>:
  <D.25101>:
  <D.25102>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52344 = bin_int_table[D.52336][D.52338];
  ins->type = D.52344;
  D.52333 = ins->opcode;
  D.52340 = ins->type;
  D.52341 = (int) D.52340;
  D.52342 = binops_op_map[D.52341];
  D.52343 = D.52333 + D.52342;
  ins->opcode = D.52343;
  goto <D.25097>;
  <D.25103>:
  <D.25104>:
  <D.25105>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52345 = shift_table[D.52336][D.52338];
  ins->type = D.52345;
  D.52333 = ins->opcode;
  D.52340 = ins->type;
  D.52341 = (int) D.52340;
  D.52342 = binops_op_map[D.52341];
  D.52343 = D.52333 + D.52342;
  ins->opcode = D.52343;
  goto <D.25097>;
  <D.25106>:
  <D.25107>:
  <D.25108>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52346 = bin_comp_table[D.52336][D.52338];
  D.52347 = D.52346 != 0;
  D.52348 = (unsigned char) D.52347;
  ins->type = D.52348;
  D.52335 = src1->type;
  if (D.52335 == 2) goto <D.52349>; else goto <D.52352>;
  <D.52352>:
  D.52335 = src1->type;
  if (D.52335 == 3) goto <D.52349>; else goto <D.52353>;
  <D.52353>:
  D.52335 = src1->type;
  if (D.52335 == 6) goto <D.52349>; else goto <D.52354>;
  <D.52354>:
  D.52335 = src1->type;
  if (D.52335 == 5) goto <D.52349>; else goto <D.52350>;
  <D.52349>:
  ins->opcode = 325;
  goto <D.52351>;
  <D.52350>:
  D.52335 = src1->type;
  if (D.52335 == 4) goto <D.52355>; else goto <D.52356>;
  <D.52355>:
  ins->opcode = 324;
  goto <D.52357>;
  <D.52356>:
  ins->opcode = 326;
  <D.52357>:
  <D.52351>:
  goto <D.25097>;
  <D.25109>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52358 = bin_comp_table[D.52336][D.52336];
  D.52359 = D.52358 != 0;
  D.52360 = (unsigned char) D.52359;
  ins->type = D.52360;
  D.52335 = src1->type;
  if (D.52335 == 2) goto <D.52361>; else goto <D.52363>;
  <D.52363>:
  D.52335 = src1->type;
  if (D.52335 == 3) goto <D.52361>; else goto <D.52364>;
  <D.52364>:
  D.52335 = src1->type;
  if (D.52335 == 6) goto <D.52361>; else goto <D.52365>;
  <D.52365>:
  D.52335 = src1->type;
  if (D.52335 == 5) goto <D.52361>; else goto <D.52362>;
  <D.52361>:
  ins->opcode = 328;
  <D.52362>:
  goto <D.25097>;
  <D.25110>:
  <D.25111>:
  <D.25112>:
  <D.25113>:
  <D.25114>:
  <D.25115>:
  <D.25116>:
  <D.25117>:
  <D.25118>:
  <D.25119>:
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52366 = beqops_op_map[D.52336];
  D.52367 = D.52333 + D.52366;
  ins->opcode = D.52367;
  goto <D.25097>;
  <D.25120>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52346 = bin_comp_table[D.52336][D.52338];
  D.52347 = D.52346 != 0;
  D.52348 = (unsigned char) D.52347;
  ins->type = D.52348;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52368 = ceqops_op_map[D.52336];
  D.52369 = D.52333 + D.52368;
  ins->opcode = D.52369;
  goto <D.25097>;
  <D.25121>:
  <D.25122>:
  <D.25123>:
  <D.25124>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52346 = bin_comp_table[D.52336][D.52338];
  D.52370 = (int) D.52346;
  D.52371 = D.52370 & 1;
  D.52372 = D.52371 != 0;
  D.52373 = (unsigned char) D.52372;
  ins->type = D.52373;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52368 = ceqops_op_map[D.52336];
  D.52369 = D.52333 + D.52368;
  ins->opcode = D.52369;
  goto <D.25097>;
  <D.25125>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52374 = neg_table[D.52336];
  ins->type = D.52374;
  D.52333 = ins->opcode;
  D.52340 = ins->type;
  D.52341 = (int) D.52340;
  D.52375 = unops_op_map[D.52341];
  D.52376 = D.52333 + D.52375;
  ins->opcode = D.52376;
  goto <D.25097>;
  <D.25126>:
  D.52335 = src1->type;
  D.52377 = D.52335 + 255;
  if (D.52377 <= 2) goto <D.52378>; else goto <D.52379>;
  <D.52378>:
  D.52335 = src1->type;
  ins->type = D.52335;
  goto <D.52380>;
  <D.52379>:
  ins->type = 0;
  <D.52380>:
  D.52333 = ins->opcode;
  D.52340 = ins->type;
  D.52341 = (int) D.52340;
  D.52375 = unops_op_map[D.52341];
  D.52376 = D.52333 + D.52375;
  ins->opcode = D.52376;
  goto <D.25097>;
  <D.25127>:
  <D.25128>:
  <D.25129>:
  <D.25130>:
  ins->type = 1;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52381 = unops_op_map[D.52336];
  D.52382 = D.52333 + D.52381;
  ins->opcode = D.52382;
  goto <D.25097>;
  <D.25131>:
  ins->type = 4;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  switch (D.52336) <default: <D.52383>, case 1: <D.25132>, case 2: <D.25135>, case 3: <D.25133>>
  <D.25132>:
  <D.25133>:
  ins->opcode = 588;
  goto <D.25134>;
  <D.25135>:
  ins->opcode = 536;
  goto <D.25134>;
  <D.52383>:
  <D.25134>:
  goto <D.25097>;
  <D.25136>:
  <D.25137>:
  <D.25138>:
  <D.25139>:
  <D.25140>:
  <D.25141>:
  ins->type = 1;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52384 = ovf3ops_op_map[D.52336];
  D.52385 = D.52333 + D.52384;
  ins->opcode = D.52385;
  goto <D.25097>;
  <D.25142>:
  <D.25143>:
  ins->type = 3;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52386 = ovf2ops_op_map[D.52336];
  D.52387 = D.52333 + D.52386;
  ins->opcode = D.52387;
  goto <D.25097>;
  <D.25144>:
  <D.25145>:
  <D.25146>:
  <D.25147>:
  <D.25148>:
  <D.25149>:
  ins->type = 1;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52386 = ovf2ops_op_map[D.52336];
  D.52387 = D.52333 + D.52386;
  ins->opcode = D.52387;
  goto <D.25097>;
  <D.25150>:
  ins->type = 3;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  switch (D.52336) <default: <D.52388>, case 1: <D.25151>, case 2: <D.25155>, case 3: <D.25153>, case 4: <D.25156>, case 5: <D.25154>>
  <D.25151>:
  ins->opcode = 589;
  goto <D.25152>;
  <D.25153>:
  <D.25154>:
  ins->opcode = 537;
  goto <D.25152>;
  <D.25155>:
  ins->opcode = 537;
  goto <D.25152>;
  <D.25156>:
  ins->opcode = 727;
  goto <D.25152>;
  <D.52388>:
  <D.25152>:
  goto <D.25097>;
  <D.25157>:
  <D.25158>:
  ins->type = 2;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52381 = unops_op_map[D.52336];
  D.52382 = D.52333 + D.52381;
  ins->opcode = D.52382;
  goto <D.25097>;
  <D.25159>:
  <D.25160>:
  ins->type = 2;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52384 = ovf3ops_op_map[D.52336];
  D.52385 = D.52333 + D.52384;
  ins->opcode = D.52385;
  goto <D.25097>;
  <D.25161>:
  <D.25162>:
  ins->type = 2;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52386 = ovf2ops_op_map[D.52336];
  D.52387 = D.52333 + D.52386;
  ins->opcode = D.52387;
  goto <D.25097>;
  <D.25163>:
  <D.25164>:
  ins->type = 4;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52381 = unops_op_map[D.52336];
  D.52382 = D.52333 + D.52381;
  ins->opcode = D.52382;
  goto <D.25097>;
  <D.25165>:
  ins->type = 4;
  goto <D.25097>;
  <D.25166>:
  <D.25167>:
  ins->type = 1;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52389 = ovfops_op_map[D.52336];
  D.52390 = D.52333 + D.52389;
  ins->opcode = D.52390;
  goto <D.25097>;
  <D.25168>:
  <D.25169>:
  <D.25170>:
  ins->type = 3;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52389 = ovfops_op_map[D.52336];
  D.52390 = D.52333 + D.52389;
  ins->opcode = D.52390;
  goto <D.25097>;
  <D.25171>:
  <D.25172>:
  <D.25173>:
  <D.25174>:
  <D.25175>:
  <D.25176>:
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52337 = src2->type;
  D.52338 = (int) D.52337;
  D.52339 = bin_num_table[D.52336][D.52338];
  ins->type = D.52339;
  D.52333 = ins->opcode;
  D.52335 = src1->type;
  D.52336 = (int) D.52335;
  D.52389 = ovfops_op_map[D.52336];
  D.52390 = D.52333 + D.52389;
  ins->opcode = D.52390;
  D.52340 = ins->type;
  if (D.52340 == 4) goto <D.52391>; else goto <D.52392>;
  <D.52391>:
  ins->type = 0;
  <D.52392>:
  goto <D.25097>;
  <D.25177>:
  ins->type = 3;
  goto <D.25097>;
  <D.25178>:
  <D.25179>:
  <D.25180>:
  <D.25181>:
  <D.25182>:
  <D.25183>:
  ins->type = 3;
  goto <D.25097>;
  <D.25184>:
  ins->type = 2;
  goto <D.25097>;
  <D.25185>:
  <D.25186>:
  ins->type = 4;
  goto <D.25097>;
  <D.25187>:
  D.52333 = ins->opcode;
  D.52334 = (int) D.52333;
  monoeg_g_log (0B, 4, "opcode 0x%04x not handled in type from op", D.52334);
  <D.25188>:
  goto <D.25188>;
  <D.25097>:
  D.52340 = ins->type;
  if (D.52340 == 5) goto <D.52393>; else goto <D.52394>;
  <D.52393>:
  D.52395 = mono_defaults.object_class;
  ins->klass = D.52395;
  <D.52394>:
}


mono_save_token_info (struct MonoCompile * cfg, struct MonoImage * image, guint32 token, void * key)
{
  long unsigned int D.52397;
  long unsigned int D.52398;
  struct MonoGenericContext * D.52401;
  unsigned int D.52404;
  struct MonoMemPool * D.52407;
  struct GHashTable * D.52408;

  D.52397 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52398 = D.52397 & 274877906944;
  if (D.52398 != 0) goto <D.52399>; else goto <D.52400>;
  <D.52399>:
  D.52401 = cfg->generic_context;
  if (D.52401 == 0B) goto <D.52402>; else goto <D.52403>;
  <D.52402>:
  D.52404 = token >> 24;
  if (D.52404 != 0) goto <D.52405>; else goto <D.52406>;
  <D.52405>:
  {
    struct MonoJumpInfoToken * jump_info_token;

    D.52407 = cfg->mempool;
    jump_info_token = mono_mempool_alloc0 (D.52407, 32);
    jump_info_token->image = image;
    jump_info_token->token = token;
    D.52408 = cfg->token_info_hash;
    monoeg_g_hash_table_insert_replace (D.52408, key, jump_info_token, 0);
  }
  <D.52406>:
  <D.52403>:
  <D.52400>:
}


ip_in_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const guint8 * ip)
{
  struct MonoBasicBlock * * D.52409;
  long int ip.499;
  unsigned char * D.52411;
  long int D.52412;
  long int D.52413;
  long unsigned int D.52414;
  long unsigned int D.52415;
  struct MonoBasicBlock * * D.52416;
  gboolean D.52417;
  int iftmp.500;
  struct MonoBasicBlock * b;

  D.52409 = cfg->cil_offset_to_bb;
  ip.499 = (long int) ip;
  D.52411 = cfg->cil_start;
  D.52412 = (long int) D.52411;
  D.52413 = ip.499 - D.52412;
  D.52414 = (long unsigned int) D.52413;
  D.52415 = D.52414 * 8;
  D.52416 = D.52409 + D.52415;
  b = *D.52416;
  if (b == 0B) goto <D.52419>; else goto <D.52422>;
  <D.52422>:
  if (b == bb) goto <D.52419>; else goto <D.52420>;
  <D.52419>:
  iftmp.500 = 1;
  goto <D.52421>;
  <D.52420>:
  iftmp.500 = 0;
  <D.52421>:
  D.52417 = iftmp.500;
  return D.52417;
}


handle_delegate_ctor (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * target, struct MonoMethod * method, int context_used)
{
  struct MonoInst * D.52426;
  short unsigned int D.52429;
  void * D.52431;
  struct MonoMemPool * D.52432;
  long int D.52433;
  struct MonoInst * D.52434;
  int D.52435;
  int D.52436;
  const unsigned char * D.52437;
  int D.52438;
  int D.52439;
  struct MonoBasicBlock * D.52440;
  struct MonoInst * D.52441;
  long unsigned int D.52445;
  long unsigned int D.52446;
  unsigned int D.52449;
  long int D.52450;
  struct MonoInst * D.52451;
  int D.52452;
  int D.52453;
  long int D.52457;
  struct MonoInst * D.52458;
  int D.52459;
  int D.52460;
  int D.52461;
  unsigned int D.52467;
  long unsigned int D.52471;
  long unsigned int D.52472;
  unsigned int D.52475;
  unsigned int D.52476;
  union mono_mutex_t * D.52482;
  _Bool D.52485;
  long int D.52486;
  long int D.52487;
  void * D.52490;
  struct GHashTable * D.52491;
  struct GHashTable * D.52494;
  _Bool D.52499;
  long int D.52500;
  long int D.52501;
  long unsigned int D.52504;
  long int D.52507;
  struct MonoInst * D.52508;
  guint16 iftmp.501;
  int D.52513;
  int D.52514;
  long int D.52517;
  struct MonoInst * D.52518;
  int D.52519;
  int D.52520;
  int D.52521;
  unsigned int D.52523;
  int D.52524;
  unsigned int D.52529;
  int D.52530;
  long int D.52534;
  struct MonoInst * D.52535;
  int D.52536;
  int D.52537;
  int D.52538;
  long int D.52544;
  struct MonoInst * D.52545;
  guint16 iftmp.502;
  int D.52550;
  int D.52551;
  long int D.52554;
  struct MonoInst * D.52555;
  int D.52556;
  int D.52557;
  int D.52558;
  unsigned int D.52560;
  int D.52561;
  struct MonoDomain * D.52566;
  unsigned int D.52567;
  int D.52568;
  long int D.52572;
  struct MonoInst * D.52573;
  int D.52574;
  int D.52575;
  int D.52576;
  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.52424>; else goto <D.52425>;
  <D.52424>:
  D.52426 = 0B;
  return D.52426;
  <D.52425>:
  D.52429 = target->opcode;
  if (D.52429 != 363) goto <D.52427>; else goto <D.52430>;
  <D.52430>:
  D.52431 = target->data.op[0].p;
  if (D.52431 != 0B) goto <D.52427>; else goto <D.52428>;
  <D.52427>:
  {
    struct MonoInst * inst;

    D.52432 = cfg->mempool;
    inst = mono_mempool_alloc (D.52432, 80);
    inst->data.op[1].const_val = 0;
    D.52433 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52433;
    inst->prev = 0B;
    D.52434 = inst->prev;
    inst->next = D.52434;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52435 = inst->sreg3;
    inst->sreg2 = D.52435;
    D.52436 = inst->sreg2;
    inst->sreg1 = D.52436;
    D.52437 = cfg->ip;
    inst->cil_code = D.52437;
    D.52438 = target->dreg;
    inst->sreg1 = D.52438;
    D.52439 = obj->dreg;
    inst->dreg = D.52439;
    inst->data.op[0].const_val = 32;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    if (D.52441 != 0B) goto <D.52442>; else goto <D.52443>;
    <D.52442>:
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    D.52441->next = inst;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    inst->prev = D.52441;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    goto <D.52444>;
    <D.52443>:
    D.52440 = cfg->cbb;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    D.52441 = D.52440->last_ins;
    D.52440->code = D.52441;
    <D.52444>:
  }
  D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52446 = D.52445 & 1152921504606846976;
  if (D.52446 != 0) goto <D.52447>; else goto <D.52448>;
  <D.52447>:
  D.52449 = alloc_preg (cfg);
  dreg = (int) D.52449;
  D.52432 = cfg->mempool;
  ptr = mono_mempool_alloc (D.52432, 80);
  ptr->data.op[1].const_val = 0;
  D.52450 = ptr->data.op[1].const_val;
  ptr->data.op[0].const_val = D.52450;
  ptr->prev = 0B;
  D.52451 = ptr->prev;
  ptr->next = D.52451;
  ptr->opcode = 538;
  ptr->flags = 0;
  ptr->type = 0;
  ptr->dreg = -1;
  ptr->sreg3 = -1;
  D.52452 = ptr->sreg3;
  ptr->sreg2 = D.52452;
  D.52453 = ptr->sreg2;
  ptr->sreg1 = D.52453;
  D.52437 = cfg->ip;
  ptr->cil_code = D.52437;
  ptr->dreg = dreg;
  D.52439 = obj->dreg;
  ptr->sreg1 = D.52439;
  ptr->data.op[1].const_val = 32;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  if (D.52441 != 0B) goto <D.52454>; else goto <D.52455>;
  <D.52454>:
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  D.52441->next = ptr;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  ptr->prev = D.52441;
  D.52440 = cfg->cbb;
  D.52440->last_ins = ptr;
  goto <D.52456>;
  <D.52455>:
  D.52440 = cfg->cbb;
  D.52440 = cfg->cbb;
  D.52440->last_ins = ptr;
  D.52441 = D.52440->last_ins;
  D.52440->code = D.52441;
  <D.52456>:
  emit_write_barrier (cfg, ptr, target);
  <D.52448>:
  <D.52428>:
  method_ins = emit_get_rgctx_method (cfg, context_used, method, 5);
  {
    struct MonoInst * inst;

    D.52432 = cfg->mempool;
    inst = mono_mempool_alloc (D.52432, 80);
    inst->data.op[1].const_val = 0;
    D.52457 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52457;
    inst->prev = 0B;
    D.52458 = inst->prev;
    inst->next = D.52458;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52459 = inst->sreg3;
    inst->sreg2 = D.52459;
    D.52460 = inst->sreg2;
    inst->sreg1 = D.52460;
    D.52437 = cfg->ip;
    inst->cil_code = D.52437;
    D.52461 = method_ins->dreg;
    inst->sreg1 = D.52461;
    D.52439 = obj->dreg;
    inst->dreg = D.52439;
    inst->data.op[0].const_val = 40;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    if (D.52441 != 0B) goto <D.52462>; else goto <D.52463>;
    <D.52462>:
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    D.52441->next = inst;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    inst->prev = D.52441;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    goto <D.52464>;
    <D.52463>:
    D.52440 = cfg->cbb;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    D.52441 = D.52440->last_ins;
    D.52440->code = D.52441;
    <D.52464>:
  }
  D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52446 = D.52445 & 1152921504606846976;
  if (D.52446 != 0) goto <D.52465>; else goto <D.52466>;
  <D.52465>:
  D.52467 = alloc_preg (cfg);
  dreg = (int) D.52467;
  D.52432 = cfg->mempool;
  ptr = mono_mempool_alloc (D.52432, 80);
  ptr->data.op[1].const_val = 0;
  D.52450 = ptr->data.op[1].const_val;
  ptr->data.op[0].const_val = D.52450;
  ptr->prev = 0B;
  D.52451 = ptr->prev;
  ptr->next = D.52451;
  ptr->opcode = 538;
  ptr->flags = 0;
  ptr->type = 0;
  ptr->dreg = -1;
  ptr->sreg3 = -1;
  D.52452 = ptr->sreg3;
  ptr->sreg2 = D.52452;
  D.52453 = ptr->sreg2;
  ptr->sreg1 = D.52453;
  D.52437 = cfg->ip;
  ptr->cil_code = D.52437;
  ptr->dreg = dreg;
  D.52439 = obj->dreg;
  ptr->sreg1 = D.52439;
  ptr->data.op[1].const_val = 40;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  if (D.52441 != 0B) goto <D.52468>; else goto <D.52469>;
  <D.52468>:
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  D.52441->next = ptr;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  ptr->prev = D.52441;
  D.52440 = cfg->cbb;
  D.52440->last_ins = ptr;
  goto <D.52470>;
  <D.52469>:
  D.52440 = cfg->cbb;
  D.52440 = cfg->cbb;
  D.52440->last_ins = ptr;
  D.52441 = D.52440->last_ins;
  D.52440->code = D.52441;
  <D.52470>:
  emit_write_barrier (cfg, ptr, method_ins);
  <D.52466>:
  D.52471 = BIT_FIELD_REF <*method, 64, 256>;
  D.52472 = D.52471 & 512;
  if (D.52472 == 0) goto <D.52473>; else goto <D.52474>;
  <D.52473>:
  D.52475 = cfg->opt;
  D.52476 = D.52475 & 512;
  if (D.52476 == 0) goto <D.52477>; else goto <D.52478>;
  <D.52477>:
  {
    struct MonoInst * code_slot_ins;

    if (context_used != 0) goto <D.52479>; else goto <D.52480>;
    <D.52479>:
    code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, 11);
    goto <D.52481>;
    <D.52480>:
    domain = mono_domain_get ();
    {
      int ret;

      D.52482 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.52482);
      if (ret != 0) goto <D.52483>; else goto <D.52484>;
      <D.52483>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.52484>:
      D.52485 = ret != 0;
      D.52486 = (long int) D.52485;
      D.52487 = __builtin_expect (D.52486, 0);
      if (D.52487 != 0) goto <D.52488>; else goto <D.52489>;
      <D.52488>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4431, "ret == 0");
      <D.52489>:
    }
    D.52490 = domain->runtime_info;
    D.52491 = MEM[(struct MonoJitDomainInfo *)D.52490].method_code_hash;
    if (D.52491 == 0B) goto <D.52492>; else goto <D.52493>;
    <D.52492>:
    D.52490 = domain->runtime_info;
    D.52494 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.52490].method_code_hash = D.52494;
    <D.52493>:
    D.52490 = domain->runtime_info;
    D.52491 = MEM[(struct MonoJitDomainInfo *)D.52490].method_code_hash;
    code_slot = monoeg_g_hash_table_lookup (D.52491, method);
    if (code_slot == 0B) goto <D.52495>; else goto <D.52496>;
    <D.52495>:
    code_slot = mono_domain_alloc0 (domain, 8);
    D.52490 = domain->runtime_info;
    D.52491 = MEM[(struct MonoJitDomainInfo *)D.52490].method_code_hash;
    monoeg_g_hash_table_insert_replace (D.52491, method, code_slot, 0);
    <D.52496>:
    {
      int ret;

      D.52482 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.52482);
      if (ret != 0) goto <D.52497>; else goto <D.52498>;
      <D.52497>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.52498>:
      D.52499 = ret != 0;
      D.52500 = (long int) D.52499;
      D.52501 = __builtin_expect (D.52500, 0);
      if (D.52501 != 0) goto <D.52502>; else goto <D.52503>;
      <D.52502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4439, "ret == 0");
      <D.52503>:
    }
    D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.52504 = D.52445 & 274877906944;
    if (D.52504 != 0) goto <D.52505>; else goto <D.52506>;
    <D.52505>:
    D.52432 = cfg->mempool;
    code_slot_ins = mono_mempool_alloc (D.52432, 80);
    code_slot_ins->data.op[1].const_val = 0;
    D.52507 = code_slot_ins->data.op[1].const_val;
    code_slot_ins->data.op[0].const_val = D.52507;
    code_slot_ins->prev = 0B;
    D.52508 = code_slot_ins->prev;
    code_slot_ins->next = D.52508;
    D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.52504 = D.52445 & 274877906944;
    if (D.52504 != 0) goto <D.52510>; else goto <D.52511>;
    <D.52510>:
    iftmp.501 = 734;
    goto <D.52512>;
    <D.52511>:
    iftmp.501 = 363;
    <D.52512>:
    code_slot_ins->opcode = iftmp.501;
    code_slot_ins->flags = 0;
    code_slot_ins->type = 0;
    code_slot_ins->dreg = -1;
    code_slot_ins->sreg3 = -1;
    D.52513 = code_slot_ins->sreg3;
    code_slot_ins->sreg2 = D.52513;
    D.52514 = code_slot_ins->sreg2;
    code_slot_ins->sreg1 = D.52514;
    D.52437 = cfg->ip;
    code_slot_ins->cil_code = D.52437;
    D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.52504 = D.52445 & 274877906944;
    if (D.52504 != 0) goto <D.52515>; else goto <D.52516>;
    <D.52515>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.52432 = cfg->mempool;
      group = mono_mempool_alloc (D.52432, 80);
      group->data.op[1].const_val = 0;
      D.52517 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.52517;
      group->prev = 0B;
      D.52518 = group->prev;
      group->next = D.52518;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.52519 = group->sreg3;
      group->sreg2 = D.52519;
      D.52520 = group->sreg2;
      group->sreg1 = D.52520;
      D.52437 = cfg->ip;
      group->cil_code = D.52437;
      group->data.op[0].src = method;
      group->data.op[1].src = 50B;
      D.52521 = got_loc->dreg;
      code_slot_ins->sreg1 = D.52521;
      code_slot_ins->data.op[1].p = group;
    }
    goto <D.52522>;
    <D.52516>:
    code_slot_ins->data.op[0].p = method;
    code_slot_ins->data.op[1].src = 50B;
    <D.52522>:
    code_slot_ins->type = 3;
    D.52523 = alloc_dreg (cfg, 3);
    D.52524 = (int) D.52523;
    code_slot_ins->dreg = D.52524;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    if (D.52441 != 0B) goto <D.52525>; else goto <D.52526>;
    <D.52525>:
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    D.52441->next = code_slot_ins;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    code_slot_ins->prev = D.52441;
    D.52440 = cfg->cbb;
    D.52440->last_ins = code_slot_ins;
    goto <D.52527>;
    <D.52526>:
    D.52440 = cfg->cbb;
    D.52440 = cfg->cbb;
    D.52440->last_ins = code_slot_ins;
    D.52441 = D.52440->last_ins;
    D.52440->code = D.52441;
    <D.52527>:
    goto <D.52528>;
    <D.52506>:
    D.52432 = cfg->mempool;
    code_slot_ins = mono_mempool_alloc (D.52432, 80);
    code_slot_ins->data.op[1].const_val = 0;
    D.52507 = code_slot_ins->data.op[1].const_val;
    code_slot_ins->data.op[0].const_val = D.52507;
    code_slot_ins->prev = 0B;
    D.52508 = code_slot_ins->prev;
    code_slot_ins->next = D.52508;
    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.52513 = code_slot_ins->sreg3;
    code_slot_ins->sreg2 = D.52513;
    D.52514 = code_slot_ins->sreg2;
    code_slot_ins->sreg1 = D.52514;
    D.52437 = cfg->ip;
    code_slot_ins->cil_code = D.52437;
    code_slot_ins->data.op[0].p = code_slot;
    code_slot_ins->type = 3;
    D.52529 = alloc_dreg (cfg, 3);
    D.52530 = (int) D.52529;
    code_slot_ins->dreg = D.52530;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    if (D.52441 != 0B) goto <D.52531>; else goto <D.52532>;
    <D.52531>:
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    D.52441->next = code_slot_ins;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    code_slot_ins->prev = D.52441;
    D.52440 = cfg->cbb;
    D.52440->last_ins = code_slot_ins;
    goto <D.52533>;
    <D.52532>:
    D.52440 = cfg->cbb;
    D.52440 = cfg->cbb;
    D.52440->last_ins = code_slot_ins;
    D.52441 = D.52440->last_ins;
    D.52440->code = D.52441;
    <D.52533>:
    <D.52528>:
    <D.52481>:
    {
      struct MonoInst * inst;

      D.52432 = cfg->mempool;
      inst = mono_mempool_alloc (D.52432, 80);
      inst->data.op[1].const_val = 0;
      D.52534 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.52534;
      inst->prev = 0B;
      D.52535 = inst->prev;
      inst->next = D.52535;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.52536 = inst->sreg3;
      inst->sreg2 = D.52536;
      D.52537 = inst->sreg2;
      inst->sreg1 = D.52537;
      D.52437 = cfg->ip;
      inst->cil_code = D.52437;
      D.52538 = code_slot_ins->dreg;
      inst->sreg1 = D.52538;
      D.52439 = obj->dreg;
      inst->dreg = D.52439;
      inst->data.op[0].const_val = 56;
      D.52440 = cfg->cbb;
      D.52441 = D.52440->last_ins;
      if (D.52441 != 0B) goto <D.52539>; else goto <D.52540>;
      <D.52539>:
      D.52440 = cfg->cbb;
      D.52441 = D.52440->last_ins;
      D.52441->next = inst;
      D.52440 = cfg->cbb;
      D.52441 = D.52440->last_ins;
      inst->prev = D.52441;
      D.52440 = cfg->cbb;
      D.52440->last_ins = inst;
      goto <D.52541>;
      <D.52540>:
      D.52440 = cfg->cbb;
      D.52440 = cfg->cbb;
      D.52440->last_ins = inst;
      D.52441 = D.52440->last_ins;
      D.52440->code = D.52441;
      <D.52541>:
    }
  }
  <D.52478>:
  <D.52474>:
  D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52504 = D.52445 & 274877906944;
  if (D.52504 != 0) goto <D.52542>; else goto <D.52543>;
  <D.52542>:
  D.52432 = cfg->mempool;
  tramp_ins = mono_mempool_alloc (D.52432, 80);
  tramp_ins->data.op[1].const_val = 0;
  D.52544 = tramp_ins->data.op[1].const_val;
  tramp_ins->data.op[0].const_val = D.52544;
  tramp_ins->prev = 0B;
  D.52545 = tramp_ins->prev;
  tramp_ins->next = D.52545;
  D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52504 = D.52445 & 274877906944;
  if (D.52504 != 0) goto <D.52547>; else goto <D.52548>;
  <D.52547>:
  iftmp.502 = 734;
  goto <D.52549>;
  <D.52548>:
  iftmp.502 = 363;
  <D.52549>:
  tramp_ins->opcode = iftmp.502;
  tramp_ins->flags = 0;
  tramp_ins->type = 0;
  tramp_ins->dreg = -1;
  tramp_ins->sreg3 = -1;
  D.52550 = tramp_ins->sreg3;
  tramp_ins->sreg2 = D.52550;
  D.52551 = tramp_ins->sreg2;
  tramp_ins->sreg1 = D.52551;
  D.52437 = cfg->ip;
  tramp_ins->cil_code = D.52437;
  D.52445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52504 = D.52445 & 274877906944;
  if (D.52504 != 0) goto <D.52552>; else goto <D.52553>;
  <D.52552>:
  {
    struct MonoInst * group;
    struct MonoInst * got_loc;

    got_loc = mono_get_got_var (cfg);
    D.52432 = cfg->mempool;
    group = mono_mempool_alloc (D.52432, 80);
    group->data.op[1].const_val = 0;
    D.52554 = group->data.op[1].const_val;
    group->data.op[0].const_val = D.52554;
    group->prev = 0B;
    D.52555 = group->prev;
    group->next = D.52555;
    group->opcode = 733;
    group->flags = 0;
    group->type = 0;
    group->dreg = -1;
    group->sreg3 = -1;
    D.52556 = group->sreg3;
    group->sreg2 = D.52556;
    D.52557 = group->sreg2;
    group->sreg1 = D.52557;
    D.52437 = cfg->ip;
    group->cil_code = D.52437;
    group->data.op[0].src = klass;
    group->data.op[1].src = 30B;
    D.52558 = got_loc->dreg;
    tramp_ins->sreg1 = D.52558;
    tramp_ins->data.op[1].p = group;
  }
  goto <D.52559>;
  <D.52553>:
  tramp_ins->data.op[0].p = klass;
  tramp_ins->data.op[1].src = 30B;
  <D.52559>:
  tramp_ins->type = 3;
  D.52560 = alloc_dreg (cfg, 3);
  D.52561 = (int) D.52560;
  tramp_ins->dreg = D.52561;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  if (D.52441 != 0B) goto <D.52562>; else goto <D.52563>;
  <D.52562>:
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  D.52441->next = tramp_ins;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  tramp_ins->prev = D.52441;
  D.52440 = cfg->cbb;
  D.52440->last_ins = tramp_ins;
  goto <D.52564>;
  <D.52563>:
  D.52440 = cfg->cbb;
  D.52440 = cfg->cbb;
  D.52440->last_ins = tramp_ins;
  D.52441 = D.52440->last_ins;
  D.52440->code = D.52441;
  <D.52564>:
  goto <D.52565>;
  <D.52543>:
  D.52566 = cfg->domain;
  trampoline = mono_create_delegate_trampoline (D.52566, klass);
  D.52432 = cfg->mempool;
  tramp_ins = mono_mempool_alloc (D.52432, 80);
  tramp_ins->data.op[1].const_val = 0;
  D.52544 = tramp_ins->data.op[1].const_val;
  tramp_ins->data.op[0].const_val = D.52544;
  tramp_ins->prev = 0B;
  D.52545 = tramp_ins->prev;
  tramp_ins->next = D.52545;
  tramp_ins->opcode = 363;
  tramp_ins->flags = 0;
  tramp_ins->type = 0;
  tramp_ins->dreg = -1;
  tramp_ins->sreg3 = -1;
  D.52550 = tramp_ins->sreg3;
  tramp_ins->sreg2 = D.52550;
  D.52551 = tramp_ins->sreg2;
  tramp_ins->sreg1 = D.52551;
  D.52437 = cfg->ip;
  tramp_ins->cil_code = D.52437;
  tramp_ins->data.op[0].p = trampoline;
  tramp_ins->type = 3;
  D.52567 = alloc_dreg (cfg, 3);
  D.52568 = (int) D.52567;
  tramp_ins->dreg = D.52568;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  if (D.52441 != 0B) goto <D.52569>; else goto <D.52570>;
  <D.52569>:
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  D.52441->next = tramp_ins;
  D.52440 = cfg->cbb;
  D.52441 = D.52440->last_ins;
  tramp_ins->prev = D.52441;
  D.52440 = cfg->cbb;
  D.52440->last_ins = tramp_ins;
  goto <D.52571>;
  <D.52570>:
  D.52440 = cfg->cbb;
  D.52440 = cfg->cbb;
  D.52440->last_ins = tramp_ins;
  D.52441 = D.52440->last_ins;
  D.52440->code = D.52441;
  <D.52571>:
  <D.52565>:
  {
    struct MonoInst * inst;

    D.52432 = cfg->mempool;
    inst = mono_mempool_alloc (D.52432, 80);
    inst->data.op[1].const_val = 0;
    D.52572 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.52572;
    inst->prev = 0B;
    D.52573 = inst->prev;
    inst->next = D.52573;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.52574 = inst->sreg3;
    inst->sreg2 = D.52574;
    D.52575 = inst->sreg2;
    inst->sreg1 = D.52575;
    D.52437 = cfg->ip;
    inst->cil_code = D.52437;
    D.52576 = tramp_ins->dreg;
    inst->sreg1 = D.52576;
    D.52439 = obj->dreg;
    inst->dreg = D.52439;
    inst->data.op[0].const_val = 24;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    if (D.52441 != 0B) goto <D.52577>; else goto <D.52578>;
    <D.52577>:
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    D.52441->next = inst;
    D.52440 = cfg->cbb;
    D.52441 = D.52440->last_ins;
    inst->prev = D.52441;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    goto <D.52579>;
    <D.52578>:
    D.52440 = cfg->cbb;
    D.52440 = cfg->cbb;
    D.52440->last_ins = inst;
    D.52441 = D.52440->last_ins;
    D.52440->code = D.52441;
    <D.52579>:
  }
  D.52426 = obj;
  return D.52426;
}


mini_get_method (struct MonoCompile * cfg, struct MonoMethod * m, guint32 token, struct MonoClass * klass, struct MonoGenericContext * context)
{
  struct MonoGenericSharingContext * D.52585;
  struct MonoClass * D.52588;
  struct MonoType * D.52589;
  int D.52590;
  struct MonoMethod * D.52593;
  struct MonoMethod * method;

  method = mini_get_method_allow_open (m, token, klass, context);
  if (method != 0B) goto <D.52581>; else goto <D.52582>;
  <D.52581>:
  if (cfg != 0B) goto <D.52583>; else goto <D.52584>;
  <D.52583>:
  D.52585 = cfg->generic_sharing_context;
  if (D.52585 == 0B) goto <D.52586>; else goto <D.52587>;
  <D.52586>:
  D.52588 = method->klass;
  D.52589 = &D.52588->byval_arg;
  D.52590 = mono_class_is_open_constructed_type (D.52589);
  if (D.52590 != 0) goto <D.52591>; else goto <D.52592>;
  <D.52591>:
  D.52593 = 0B;
  return D.52593;
  <D.52592>:
  <D.52587>:
  <D.52584>:
  <D.52582>:
  D.52593 = method;
  return D.52593;
}


check_linkdemand (struct MonoCompile * cfg, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoMethod * D.52595;
  unsigned char D.52598;
  gboolean D.52601;
  struct MonoDomain * D.52602;
  struct MonoMemPool * D.52607;
  void * D.52608;
  struct MonoInst * D.52609;
  long int D.52610;
  struct MonoInst * D.52611;
  int D.52612;
  int D.52613;
  const unsigned char * D.52614;
  unsigned int D.52615;
  int D.52616;
  void * D.52617;
  struct MonoInst * D.52618;
  long int D.52619;
  struct MonoInst * D.52620;
  guint16 iftmp.503;
  long unsigned int D.52622;
  long unsigned int D.52623;
  int D.52627;
  int D.52628;
  long int D.52631;
  struct MonoInst * D.52632;
  int D.52633;
  int D.52634;
  int D.52635;
  unsigned int D.52637;
  int D.52638;
  struct MonoMethod * D.52639;
  unsigned int D.52641;
  guint32 result;

  D.52595 = cfg->method;
  if (D.52595 != caller) goto <D.52596>; else goto <D.52597>;
  <D.52596>:
  D.52598 = mono_method_has_declsec (callee);
  if (D.52598 != 0) goto <D.52599>; else goto <D.52600>;
  <D.52599>:
  D.52601 = 1;
  return D.52601;
  <D.52600>:
  <D.52597>:
  D.52602 = cfg->domain;
  result = mono_declsec_linkdemand (D.52602, caller, callee);
  if (result == 0) goto <D.52603>; else goto <D.52604>;
  <D.52603>:
  D.52601 = 0;
  return D.52601;
  <D.52604>:
  if (result == 4) goto <D.52605>; else goto <D.52606>;
  <D.52605>:
  {
    struct MonoSecurityManager * secman;
    struct MonoInst * args[2];

    try
      {
        secman = mono_security_manager_get_methods ();
        D.52607 = cfg->mempool;
        D.52608 = mono_mempool_alloc (D.52607, 80);
        args[0] = D.52608;
        D.52609 = args[0];
        D.52609 = args[0];
        D.52609->data.op[1].const_val = 0;
        D.52610 = D.52609->data.op[1].const_val;
        D.52609->data.op[0].const_val = D.52610;
        D.52609 = args[0];
        D.52609 = args[0];
        D.52609->prev = 0B;
        D.52611 = D.52609->prev;
        D.52609->next = D.52611;
        D.52609 = args[0];
        D.52609->opcode = 362;
        D.52609 = args[0];
        D.52609->flags = 0;
        D.52609 = args[0];
        D.52609->type = 0;
        D.52609 = args[0];
        D.52609->dreg = -1;
        D.52609 = args[0];
        D.52609 = args[0];
        D.52609 = args[0];
        D.52609->sreg3 = -1;
        D.52612 = D.52609->sreg3;
        D.52609->sreg2 = D.52612;
        D.52613 = D.52609->sreg2;
        D.52609->sreg1 = D.52613;
        D.52609 = args[0];
        D.52614 = cfg->ip;
        D.52609->cil_code = D.52614;
        D.52609 = args[0];
        D.52609->data.op[0].const_val = 4;
        D.52609 = args[0];
        D.52609->type = 1;
        D.52609 = args[0];
        D.52615 = alloc_dreg (cfg, 1);
        D.52616 = (int) D.52615;
        D.52609->dreg = D.52616;
        D.52607 = cfg->mempool;
        D.52617 = mono_mempool_alloc (D.52607, 80);
        args[1] = D.52617;
        D.52618 = args[1];
        D.52618 = args[1];
        D.52618->data.op[1].const_val = 0;
        D.52619 = D.52618->data.op[1].const_val;
        D.52618->data.op[0].const_val = D.52619;
        D.52618 = args[1];
        D.52618 = args[1];
        D.52618->prev = 0B;
        D.52620 = D.52618->prev;
        D.52618->next = D.52620;
        D.52618 = args[1];
        D.52622 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.52623 = D.52622 & 274877906944;
        if (D.52623 != 0) goto <D.52624>; else goto <D.52625>;
        <D.52624>:
        iftmp.503 = 734;
        goto <D.52626>;
        <D.52625>:
        iftmp.503 = 363;
        <D.52626>:
        D.52618->opcode = iftmp.503;
        D.52618 = args[1];
        D.52618->flags = 0;
        D.52618 = args[1];
        D.52618->type = 0;
        D.52618 = args[1];
        D.52618->dreg = -1;
        D.52618 = args[1];
        D.52618 = args[1];
        D.52618 = args[1];
        D.52618->sreg3 = -1;
        D.52627 = D.52618->sreg3;
        D.52618->sreg2 = D.52627;
        D.52628 = D.52618->sreg2;
        D.52618->sreg1 = D.52628;
        D.52618 = args[1];
        D.52614 = cfg->ip;
        D.52618->cil_code = D.52614;
        D.52622 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.52623 = D.52622 & 274877906944;
        if (D.52623 != 0) goto <D.52629>; else goto <D.52630>;
        <D.52629>:
        {
          struct MonoInst * group;
          struct MonoInst * got_loc;

          got_loc = mono_get_got_var (cfg);
          D.52607 = cfg->mempool;
          group = mono_mempool_alloc (D.52607, 80);
          group->data.op[1].const_val = 0;
          D.52631 = group->data.op[1].const_val;
          group->data.op[0].const_val = D.52631;
          group->prev = 0B;
          D.52632 = group->prev;
          group->next = D.52632;
          group->opcode = 733;
          group->flags = 0;
          group->type = 0;
          group->dreg = -1;
          group->sreg3 = -1;
          D.52633 = group->sreg3;
          group->sreg2 = D.52633;
          D.52634 = group->sreg2;
          group->sreg1 = D.52634;
          D.52614 = cfg->ip;
          group->cil_code = D.52614;
          group->data.op[0].src = caller;
          group->data.op[1].src = 6B;
          D.52618 = args[1];
          D.52635 = got_loc->dreg;
          D.52618->sreg1 = D.52635;
          D.52618 = args[1];
          D.52618->data.op[1].p = group;
        }
        goto <D.52636>;
        <D.52630>:
        D.52618 = args[1];
        D.52618->data.op[0].p = caller;
        D.52618 = args[1];
        D.52618->data.op[1].src = 6B;
        <D.52636>:
        D.52618 = args[1];
        D.52618->type = 3;
        D.52618 = args[1];
        D.52637 = alloc_dreg (cfg, 3);
        D.52638 = (int) D.52637;
        D.52618->dreg = D.52638;
        D.52639 = secman->linkdemandsecurityexception;
        mono_emit_method_call (cfg, D.52639, &args, 0B);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  goto <D.52640>;
  <D.52606>:
  D.52641 = cfg->exception_type;
  if (D.52641 == 0) goto <D.52642>; else goto <D.52643>;
  <D.52642>:
  mono_cfg_set_exception (cfg, 1);
  cfg->exception_data = result;
  D.52601 = 1;
  return D.52601;
  <D.52643>:
  <D.52640>:
  D.52601 = 0;
  return D.52601;
}


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.52645;
  struct MonoException * ex;

  D.52645 = get_original_method (caller);
  ex = mono_security_core_clr_is_call_allowed (D.52645, callee);
  if (ex != 0B) goto <D.52646>; else goto <D.52647>;
  <D.52646>:
  emit_throw_exception (cfg, ex);
  <D.52647>:
}


emit_optimized_ldloca_ir (struct MonoCompile * cfg, unsigned char * ip, unsigned char * end, int size)
{
  unsigned char * D.52650;
  unsigned char D.52651;
  const guint16 * D.52653;
  short unsigned int D.52654;
  unsigned char * D.52655;
  unsigned char D.52658;
  struct MonoBasicBlock * D.52663;
  const guint8 * D.52664;
  int D.52665;
  const guint32 * D.52668;
  unsigned int D.52669;
  struct MonoMethod * D.52670;
  unsigned int token.504;
  struct MonoGenericContext * D.52672;
  unsigned char D.52676;
  struct MonoDebugOptions * D.52677;
  int D.52678;
  struct MonoType * D.52680;
  unsigned char * D.52681;
  int local;
  int token;
  struct MonoClass * klass;
  struct MonoType * type;
  void load_error = <<< error >>>;

  if (size == 1) goto <D.52648>; else goto <D.52649>;
  <D.52648>:
  D.52650 = ip + 1;
  D.52651 = *D.52650;
  local = (int) D.52651;
  ip = ip + 2;
  goto <D.52652>;
  <D.52649>:
  D.52653 = ip + 2;
  D.52654 = *D.52653;
  local = (int) D.52654;
  ip = ip + 4;
  <D.52652>:
  D.52655 = ip + 6;
  if (D.52655 < end) goto <D.52656>; else goto <D.52657>;
  <D.52656>:
  D.52658 = *ip;
  if (D.52658 == 254) goto <D.52659>; else goto <D.52660>;
  <D.52659>:
  D.52650 = ip + 1;
  D.52651 = *D.52650;
  if (D.52651 == 21) goto <D.52661>; else goto <D.52662>;
  <D.52661>:
  D.52663 = cfg->cbb;
  D.52664 = ip + 1;
  D.52665 = ip_in_bb (cfg, D.52663, D.52664);
  if (D.52665 != 0) goto <D.52666>; else goto <D.52667>;
  <D.52666>:
  D.52668 = ip + 2;
  D.52669 = *D.52668;
  token = (int) D.52669;
  D.52670 = cfg->current_method;
  token.504 = (unsigned int) token;
  D.52672 = cfg->generic_context;
  klass = mini_get_class (D.52670, token.504, D.52672);
  if (klass == 0B) goto <D.52673>; else goto <D.52675>;
  <D.52675>:
  D.52676 = klass->exception_type;
  if (D.52676 != 0) goto <D.52673>; else goto <D.52674>;
  <D.52673>:
  cfg->exception_ptr = klass;
  D.52677 = mini_get_debug_options ();
  D.52678 = D.52677->break_on_unverified;
  if (D.52678 != 0) goto <D.52679>; else goto load_error;
  <D.52679>:
  raise (5);
  <D.52674>:
  D.52680 = &klass->byval_arg;
  type = mini_replace_type (D.52680);
  emit_init_local (cfg, local, type);
  D.52681 = ip + 6;
  return D.52681;
  <D.52667>:
  <D.52662>:
  <D.52660>:
  <D.52657>:
  load_error:
  D.52681 = 0B;
  return D.52681;
}


target_type_is_incompatible (struct MonoCompile * cfg, struct MonoType * target, struct MonoInst * arg)
{
  long unsigned int D.52683;
  long unsigned int D.52684;
  unsigned char D.52687;
  int D.52690;
  struct MonoClass * D.52691;
  struct MonoClass * D.52692;
  _Bool D.52693;
  unsigned char D.52696;
  int D.52697;
  int D.52728;
  struct MonoGenericSharingContext * D.52737;
  _Bool D.52738;
  long int D.52739;
  long int D.52740;
  int D.52743;
  struct MonoType * simple_type;
  struct MonoClass * klass;

  target = mini_replace_type (target);
  D.52683 = BIT_FIELD_REF <*target, 64, 64>;
  D.52684 = D.52683 & 1073741824;
  if (D.52684 != 0) goto <D.52685>; else goto <D.52686>;
  <D.52685>:
  D.52687 = arg->type;
  if (D.52687 == 5) goto <D.52688>; else goto <D.52689>;
  <D.52688>:
  D.52691 = arg->klass;
  D.52692 = mono_class_from_mono_type (target);
  D.52693 = D.52691 != D.52692;
  D.52690 = (int) D.52693;
  return D.52690;
  <D.52689>:
  D.52687 = arg->type;
  if (D.52687 == 3) goto <D.52694>; else goto <D.52695>;
  <D.52694>:
  D.52690 = 0;
  return D.52690;
  <D.52695>:
  D.52690 = 1;
  return D.52690;
  <D.52686>:
  simple_type = mono_type_get_underlying_type (target);
  D.52696 = simple_type->type;
  D.52697 = (int) D.52696;
  switch (D.52697) <default: <D.25712>, case 1: <D.25685>, case 2: <D.25688>, case 3: <D.25691>, case 4: <D.25686>, case 5: <D.25687>, case 6: <D.25689>, case 7: <D.25690>, case 8: <D.25692>, case 9: <D.25693>, case 10: <D.25703>, case 11: <D.25704>, case 12: <D.25705>, case 13: <D.25706>, case 14: <D.25699>, case 15: <D.25694>, case 17: <D.25707>, case 18: <D.25698>, case 19: <D.25710>, case 20: <D.25702>, case 21: <D.25709>, case 22: <D.25708>, case 24: <D.25695>, case 25: <D.25696>, case 27: <D.25697>, case 28: <D.25700>, case 29: <D.25701>, case 30: <D.25711>>
  <D.25685>:
  D.52690 = 1;
  return D.52690;
  <D.25686>:
  <D.25687>:
  <D.25688>:
  <D.25689>:
  <D.25690>:
  <D.25691>:
  <D.25692>:
  <D.25693>:
  D.52687 = arg->type;
  if (D.52687 != 1) goto <D.52698>; else goto <D.52699>;
  <D.52698>:
  D.52687 = arg->type;
  if (D.52687 != 3) goto <D.52700>; else goto <D.52701>;
  <D.52700>:
  D.52690 = 1;
  return D.52690;
  <D.52701>:
  <D.52699>:
  D.52690 = 0;
  return D.52690;
  <D.25694>:
  D.52687 = arg->type;
  if (D.52687 != 1) goto <D.52702>; else goto <D.52703>;
  <D.52702>:
  D.52687 = arg->type;
  if (D.52687 != 3) goto <D.52704>; else goto <D.52705>;
  <D.52704>:
  D.52687 = arg->type;
  if (D.52687 != 5) goto <D.52706>; else goto <D.52707>;
  <D.52706>:
  D.52690 = 1;
  return D.52690;
  <D.52707>:
  <D.52705>:
  <D.52703>:
  D.52690 = 0;
  return D.52690;
  <D.25695>:
  <D.25696>:
  <D.25697>:
  D.52687 = arg->type;
  if (D.52687 != 1) goto <D.52708>; else goto <D.52709>;
  <D.52708>:
  D.52687 = arg->type;
  if (D.52687 != 3) goto <D.52710>; else goto <D.52711>;
  <D.52710>:
  D.52687 = arg->type;
  if (D.52687 != 5) goto <D.52712>; else goto <D.52713>;
  <D.52712>:
  D.52690 = 1;
  return D.52690;
  <D.52713>:
  <D.52711>:
  <D.52709>:
  D.52690 = 0;
  return D.52690;
  <D.25698>:
  <D.25699>:
  <D.25700>:
  <D.25701>:
  <D.25702>:
  D.52687 = arg->type;
  if (D.52687 != 6) goto <D.52714>; else goto <D.52715>;
  <D.52714>:
  D.52690 = 1;
  return D.52690;
  <D.52715>:
  D.52690 = 0;
  return D.52690;
  <D.25703>:
  <D.25704>:
  D.52687 = arg->type;
  if (D.52687 != 2) goto <D.52716>; else goto <D.52717>;
  <D.52716>:
  D.52690 = 1;
  return D.52690;
  <D.52717>:
  D.52690 = 0;
  return D.52690;
  <D.25705>:
  <D.25706>:
  D.52687 = arg->type;
  if (D.52687 != 4) goto <D.52718>; else goto <D.52719>;
  <D.52718>:
  D.52690 = 1;
  return D.52690;
  <D.52719>:
  D.52690 = 0;
  return D.52690;
  <D.25707>:
  D.52687 = arg->type;
  if (D.52687 != 7) goto <D.52720>; else goto <D.52721>;
  <D.52720>:
  D.52690 = 1;
  return D.52690;
  <D.52721>:
  klass = mono_class_from_mono_type (simple_type);
  D.52691 = arg->klass;
  if (D.52691 != klass) goto <D.52722>; else goto <D.52723>;
  <D.52722>:
  D.52690 = 1;
  return D.52690;
  <D.52723>:
  D.52690 = 0;
  return D.52690;
  <D.25708>:
  D.52687 = arg->type;
  if (D.52687 != 7) goto <D.52724>; else goto <D.52725>;
  <D.52724>:
  D.52690 = 1;
  return D.52690;
  <D.52725>:
  klass = mono_class_from_mono_type (simple_type);
  D.52691 = arg->klass;
  if (D.52691 != klass) goto <D.52726>; else goto <D.52727>;
  <D.52726>:
  D.52690 = 1;
  return D.52690;
  <D.52727>:
  D.52690 = 0;
  return D.52690;
  <D.25709>:
  D.52728 = mono_type_generic_inst_is_valuetype (simple_type);
  if (D.52728 != 0) goto <D.52729>; else goto <D.52730>;
  <D.52729>:
  D.52687 = arg->type;
  if (D.52687 != 7) goto <D.52731>; else goto <D.52732>;
  <D.52731>:
  D.52690 = 1;
  return D.52690;
  <D.52732>:
  klass = mono_class_from_mono_type (simple_type);
  D.52691 = arg->klass;
  if (D.52691 != klass) goto <D.52733>; else goto <D.52734>;
  <D.52733>:
  D.52690 = 1;
  return D.52690;
  <D.52734>:
  D.52690 = 0;
  return D.52690;
  <D.52730>:
  D.52687 = arg->type;
  if (D.52687 != 6) goto <D.52735>; else goto <D.52736>;
  <D.52735>:
  D.52690 = 1;
  return D.52690;
  <D.52736>:
  D.52690 = 0;
  return D.52690;
  <D.25710>:
  <D.25711>:
  D.52737 = cfg->generic_sharing_context;
  D.52738 = D.52737 == 0B;
  D.52739 = (long int) D.52738;
  D.52740 = __builtin_expect (D.52739, 0);
  if (D.52740 != 0) goto <D.52741>; else goto <D.52742>;
  <D.52741>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2160, "cfg->generic_sharing_context");
  <D.52742>:
  D.52743 = mini_type_var_is_vt (cfg, simple_type);
  if (D.52743 != 0) goto <D.52744>; else goto <D.52745>;
  <D.52744>:
  D.52687 = arg->type;
  if (D.52687 != 7) goto <D.52746>; else goto <D.52747>;
  <D.52746>:
  D.52690 = 1;
  return D.52690;
  <D.52747>:
  goto <D.52748>;
  <D.52745>:
  D.52687 = arg->type;
  if (D.52687 != 6) goto <D.52749>; else goto <D.52750>;
  <D.52749>:
  D.52690 = 1;
  return D.52690;
  <D.52750>:
  <D.52748>:
  D.52690 = 0;
  return D.52690;
  <D.25712>:
  D.52696 = simple_type->type;
  D.52697 = (int) D.52696;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in target_type_is_incompatible", D.52697);
  <D.25713>:
  goto <D.25713>;
  D.52690 = 1;
  return D.52690;
}


emit_stloc_ir (struct MonoCompile * cfg, struct MonoInst * * sp, struct MonoMethodHeader * header, int n)
{
  struct MonoType * D.52752;
  struct MonoBasicBlock * D.52756;
  struct MonoInst * D.52757;
  struct MonoInst * D.52758;
  short unsigned int D.52760;
  short unsigned int D.52761;
  struct MonoInst * * D.52763;
  long unsigned int D.52764;
  long unsigned int D.52765;
  struct MonoInst * * D.52766;
  struct MonoInst * D.52767;
  int D.52768;
  struct MonoMemPool * D.52769;
  long int D.52770;
  struct MonoInst * D.52771;
  int D.52772;
  int D.52773;
  const unsigned char * D.52774;
  struct MonoType * D.52775;
  unsigned int D.52776;
  short unsigned int D.52777;
  struct MonoClass * D.52778;
  int D.52779;
  short unsigned int D.52780;
  struct MonoClass * D.52783;
  struct MonoInst * ins;
  guint32 opcode;

  D.52752 = header->locals[n];
  opcode = mono_type_to_regmove (cfg, D.52752);
  if (opcode == 424) goto <D.52755>; else goto <D.52753>;
  <D.52755>:
  D.52756 = cfg->cbb;
  D.52757 = D.52756->last_ins;
  D.52758 = *sp;
  if (D.52757 == D.52758) goto <D.52759>; else goto <D.52753>;
  <D.52759>:
  D.52758 = *sp;
  D.52760 = D.52758->opcode;
  D.52761 = D.52760 + 65174;
  if (D.52761 <= 1) goto <D.52762>; else goto <D.52753>;
  <D.52762>:
  D.52758 = *sp;
  D.52763 = cfg->locals;
  D.52764 = (long unsigned int) n;
  D.52765 = D.52764 * 8;
  D.52766 = D.52763 + D.52765;
  D.52767 = *D.52766;
  D.52768 = D.52767->dreg;
  D.52758->dreg = D.52768;
  goto <D.52754>;
  <D.52753>:
  D.52769 = cfg->mempool;
  ins = mono_mempool_alloc (D.52769, 80);
  ins->data.op[1].const_val = 0;
  D.52770 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52770;
  ins->prev = 0B;
  D.52771 = ins->prev;
  ins->next = D.52771;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52772 = ins->sreg3;
  ins->sreg2 = D.52772;
  D.52773 = ins->sreg2;
  ins->sreg1 = D.52773;
  D.52774 = cfg->ip;
  ins->cil_code = D.52774;
  D.52763 = cfg->locals;
  D.52764 = (long unsigned int) n;
  D.52765 = D.52764 * 8;
  D.52766 = D.52763 + D.52765;
  D.52767 = *D.52766;
  D.52775 = D.52767->data.op[1].vtype;
  D.52776 = mono_type_to_regmove (cfg, D.52775);
  D.52777 = (short unsigned int) D.52776;
  ins->opcode = D.52777;
  D.52763 = cfg->locals;
  D.52764 = (long unsigned int) n;
  D.52765 = D.52764 * 8;
  D.52766 = D.52763 + D.52765;
  D.52767 = *D.52766;
  D.52778 = D.52767->klass;
  ins->klass = D.52778;
  D.52758 = *sp;
  D.52779 = D.52758->dreg;
  ins->sreg1 = D.52779;
  D.52763 = cfg->locals;
  D.52764 = (long unsigned int) n;
  D.52765 = D.52764 * 8;
  D.52766 = D.52763 + D.52765;
  D.52767 = *D.52766;
  D.52768 = D.52767->dreg;
  ins->dreg = D.52768;
  D.52780 = ins->opcode;
  if (D.52780 == 427) goto <D.52781>; else goto <D.52782>;
  <D.52781>:
  D.52763 = cfg->locals;
  D.52764 = (long unsigned int) n;
  D.52765 = D.52764 * 8;
  D.52766 = D.52763 + D.52765;
  D.52767 = *D.52766;
  D.52775 = D.52767->data.op[1].vtype;
  D.52783 = mono_class_from_mono_type (D.52775);
  ins->klass = D.52783;
  <D.52782>:
  D.52756 = cfg->cbb;
  D.52757 = D.52756->last_ins;
  if (D.52757 != 0B) goto <D.52784>; else goto <D.52785>;
  <D.52784>:
  D.52756 = cfg->cbb;
  D.52757 = D.52756->last_ins;
  D.52757->next = ins;
  D.52756 = cfg->cbb;
  D.52757 = D.52756->last_ins;
  ins->prev = D.52757;
  D.52756 = cfg->cbb;
  D.52756->last_ins = ins;
  goto <D.52786>;
  <D.52785>:
  D.52756 = cfg->cbb;
  D.52756 = cfg->cbb;
  D.52756->last_ins = ins;
  D.52757 = D.52756->last_ins;
  D.52756->code = D.52757;
  <D.52786>:
  <D.52754>:
}


generic_class_is_reference_type (struct MonoCompile * cfg, struct MonoClass * klass)
{
  gboolean D.52787;
  struct MonoType * D.52788;

  D.52788 = &klass->byval_arg;
  D.52787 = mini_type_is_reference (cfg, D.52788);
  return D.52787;
}


mini_get_class (struct MonoMethod * method, guint32 token, struct MonoGenericContext * context)
{
  long unsigned int D.52790;
  long unsigned int D.52791;
  struct MonoClass * D.52797;
  struct MonoImage * D.52798;
  struct MonoClass * D.52801;
  struct MonoClass * klass;

  D.52790 = BIT_FIELD_REF <*method, 64, 256>;
  D.52791 = D.52790 & 124;
  if (D.52791 != 0) goto <D.52792>; else goto <D.52793>;
  <D.52792>:
  klass = mono_method_get_wrapper_data (method, token);
  if (context != 0B) goto <D.52794>; else goto <D.52795>;
  <D.52794>:
  klass = mono_class_inflate_generic_class (klass, context);
  <D.52795>:
  goto <D.52796>;
  <D.52793>:
  D.52797 = method->klass;
  D.52798 = D.52797->image;
  klass = mono_class_get_full (D.52798, token, context);
  <D.52796>:
  if (klass != 0B) goto <D.52799>; else goto <D.52800>;
  <D.52799>:
  mono_class_init (klass);
  <D.52800>:
  D.52801 = klass;
  return D.52801;
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.52803;
  long int D.52804;
  struct MonoInst * D.52805;
  int D.52806;
  int D.52807;
  const unsigned char * D.52808;
  struct MonoInst * D.52809;
  int D.52810;
  struct MonoBasicBlock * D.52811;
  struct MonoInst * D.52812;
  struct MonoInst * D.52816;
  int D.52817;
  struct MonoInst * use;

  D.52803 = cfg->mempool;
  use = mono_mempool_alloc (D.52803, 80);
  use->data.op[1].const_val = 0;
  D.52804 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.52804;
  use->prev = 0B;
  D.52805 = use->prev;
  use->next = D.52805;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.52806 = use->sreg3;
  use->sreg2 = D.52806;
  D.52807 = use->sreg2;
  use->sreg1 = D.52807;
  D.52808 = cfg->ip;
  use->cil_code = D.52808;
  D.52809 = cfg->gsharedvt_info_var;
  D.52810 = D.52809->dreg;
  use->sreg1 = D.52810;
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  if (D.52812 != 0B) goto <D.52813>; else goto <D.52814>;
  <D.52813>:
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  D.52812->next = use;
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  use->prev = D.52812;
  D.52811 = cfg->cbb;
  D.52811->last_ins = use;
  goto <D.52815>;
  <D.52814>:
  D.52811 = cfg->cbb;
  D.52811 = cfg->cbb;
  D.52811->last_ins = use;
  D.52812 = D.52811->last_ins;
  D.52811->code = D.52812;
  <D.52815>:
  D.52803 = cfg->mempool;
  use = mono_mempool_alloc (D.52803, 80);
  use->data.op[1].const_val = 0;
  D.52804 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.52804;
  use->prev = 0B;
  D.52805 = use->prev;
  use->next = D.52805;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.52806 = use->sreg3;
  use->sreg2 = D.52806;
  D.52807 = use->sreg2;
  use->sreg1 = D.52807;
  D.52808 = cfg->ip;
  use->cil_code = D.52808;
  D.52816 = cfg->gsharedvt_locals_var;
  D.52817 = D.52816->dreg;
  use->sreg1 = D.52817;
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  if (D.52812 != 0B) goto <D.52818>; else goto <D.52819>;
  <D.52818>:
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  D.52812->next = use;
  D.52811 = cfg->cbb;
  D.52812 = D.52811->last_ins;
  use->prev = D.52812;
  D.52811 = cfg->cbb;
  D.52811->last_ins = use;
  goto <D.52820>;
  <D.52819>:
  D.52811 = cfg->cbb;
  D.52811 = cfg->cbb;
  D.52811->last_ins = use;
  D.52812 = D.52811->last_ins;
  D.52811->code = D.52812;
  <D.52820>:
}


mono_emit_load_got_addr (struct MonoCompile * cfg)
{
  struct MonoInst * D.52823;
  long unsigned int D.52825;
  long unsigned int D.52826;
  struct MonoMemPool * D.52827;
  long int D.52828;
  struct MonoInst * D.52829;
  int D.52830;
  int D.52831;
  const unsigned char * D.52832;
  struct MonoMethodHeader * D.52833;
  const unsigned char * D.52834;
  int D.52835;
  struct MonoBasicBlock * D.52836;
  struct MonoInst * D.52837;
  struct MonoInst * D.52841;
  long int D.52845;
  struct MonoInst * D.52846;
  int D.52847;
  int D.52848;
  struct MonoBasicBlock * D.52849;
  struct MonoInst * D.52850;
  struct MonoInst * getaddr;
  struct MonoInst * dummy_use;

  D.52823 = cfg->got_var;
  if (D.52823 == 0B) goto <D.52821>; else goto <D.52824>;
  <D.52824>:
  D.52825 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52826 = D.52825 & 2199023255552;
  if (D.52826 != 0) goto <D.52821>; else goto <D.52822>;
  <D.52821>:
  return;
  <D.52822>:
  D.52827 = cfg->mempool;
  getaddr = mono_mempool_alloc (D.52827, 80);
  getaddr->data.op[1].const_val = 0;
  D.52828 = getaddr->data.op[1].const_val;
  getaddr->data.op[0].const_val = D.52828;
  getaddr->prev = 0B;
  D.52829 = getaddr->prev;
  getaddr->next = D.52829;
  getaddr->opcode = 795;
  getaddr->flags = 0;
  getaddr->type = 0;
  getaddr->dreg = -1;
  getaddr->sreg3 = -1;
  D.52830 = getaddr->sreg3;
  getaddr->sreg2 = D.52830;
  D.52831 = getaddr->sreg2;
  getaddr->sreg1 = D.52831;
  D.52832 = cfg->ip;
  getaddr->cil_code = D.52832;
  D.52833 = cfg->header;
  D.52834 = D.52833->code;
  getaddr->cil_code = D.52834;
  D.52823 = cfg->got_var;
  D.52835 = D.52823->dreg;
  getaddr->dreg = D.52835;
  D.52836 = cfg->bb_entry;
  D.52837 = D.52836->code;
  if (D.52837 != 0B) goto <D.52838>; else goto <D.52839>;
  <D.52838>:
  D.52836 = cfg->bb_entry;
  D.52837 = D.52836->code;
  getaddr->next = D.52837;
  D.52836 = cfg->bb_entry;
  D.52836->code = getaddr;
  goto <D.52840>;
  <D.52839>:
  D.52836 = cfg->bb_entry;
  D.52841 = D.52836->last_ins;
  if (D.52841 != 0B) goto <D.52842>; else goto <D.52843>;
  <D.52842>:
  D.52836 = cfg->bb_entry;
  D.52841 = D.52836->last_ins;
  D.52841->next = getaddr;
  D.52836 = cfg->bb_entry;
  D.52841 = D.52836->last_ins;
  getaddr->prev = D.52841;
  D.52836 = cfg->bb_entry;
  D.52836->last_ins = getaddr;
  goto <D.52844>;
  <D.52843>:
  D.52836 = cfg->bb_entry;
  D.52836 = cfg->bb_entry;
  D.52836->last_ins = getaddr;
  D.52841 = D.52836->last_ins;
  D.52836->code = D.52841;
  <D.52844>:
  <D.52840>:
  cfg->got_var_allocated = 1;
  D.52827 = cfg->mempool;
  dummy_use = mono_mempool_alloc (D.52827, 80);
  dummy_use->data.op[1].const_val = 0;
  D.52845 = dummy_use->data.op[1].const_val;
  dummy_use->data.op[0].const_val = D.52845;
  dummy_use->prev = 0B;
  D.52846 = dummy_use->prev;
  dummy_use->next = D.52846;
  dummy_use->opcode = 796;
  dummy_use->flags = 0;
  dummy_use->type = 0;
  dummy_use->dreg = -1;
  dummy_use->sreg3 = -1;
  D.52847 = dummy_use->sreg3;
  dummy_use->sreg2 = D.52847;
  D.52848 = dummy_use->sreg2;
  dummy_use->sreg1 = D.52848;
  D.52832 = cfg->ip;
  dummy_use->cil_code = D.52832;
  D.52823 = cfg->got_var;
  D.52835 = D.52823->dreg;
  dummy_use->sreg1 = D.52835;
  D.52849 = cfg->bb_exit;
  D.52850 = D.52849->last_ins;
  if (D.52850 != 0B) goto <D.52851>; else goto <D.52852>;
  <D.52851>:
  D.52849 = cfg->bb_exit;
  D.52850 = D.52849->last_ins;
  D.52850->next = dummy_use;
  D.52849 = cfg->bb_exit;
  D.52850 = D.52849->last_ins;
  dummy_use->prev = D.52850;
  D.52849 = cfg->bb_exit;
  D.52849->last_ins = dummy_use;
  goto <D.52853>;
  <D.52852>:
  D.52849 = cfg->bb_exit;
  D.52849 = cfg->bb_exit;
  D.52849->last_ins = dummy_use;
  D.52850 = D.52849->last_ins;
  D.52849->code = D.52850;
  <D.52853>:
}


emit_init_local (struct MonoCompile * cfg, int local, struct MonoType * type)
{
  struct MonoInst * * D.52855;
  long unsigned int D.52856;
  long unsigned int D.52857;
  struct MonoInst * * D.52858;
  unsigned char D.52861;
  <unnamed type> D.52862;
  unsigned int D.52863;
  struct MonoMemPool * D.52864;
  long int D.52865;
  struct MonoInst * D.52866;
  int D.52867;
  int D.52868;
  const unsigned char * D.52869;
  struct MonoInst * D.52870;
  struct MonoType * D.52871;
  unsigned int D.52872;
  short unsigned int D.52873;
  struct MonoClass * D.52874;
  struct MonoBasicBlock * D.52875;
  struct MonoInst * D.52876;
  int D.52877;
  int D.52878;
  short unsigned int D.52879;
  struct MonoClass * D.52882;
  int D.52887;
  struct MonoInst * var;

  D.52855 = cfg->locals;
  D.52856 = (long unsigned int) local;
  D.52857 = D.52856 * 8;
  D.52858 = D.52855 + D.52857;
  var = *D.52858;
  if (0 != 0) goto <D.52859>; else goto <D.52860>;
  <D.52859>:
  {
    struct MonoInst * store;
    int reg;

    D.52861 = var->type;
    D.52862 = (<unnamed type>) D.52861;
    D.52863 = alloc_dreg (cfg, D.52862);
    reg = (int) D.52863;
    emit_init_rvar (cfg, reg, type);
    D.52864 = cfg->mempool;
    store = mono_mempool_alloc (D.52864, 80);
    store->data.op[1].const_val = 0;
    D.52865 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.52865;
    store->prev = 0B;
    D.52866 = store->prev;
    store->next = D.52866;
    store->opcode = 424;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.52867 = store->sreg3;
    store->sreg2 = D.52867;
    D.52868 = store->sreg2;
    store->sreg1 = D.52868;
    D.52869 = cfg->ip;
    store->cil_code = D.52869;
    D.52855 = cfg->locals;
    D.52856 = (long unsigned int) local;
    D.52857 = D.52856 * 8;
    D.52858 = D.52855 + D.52857;
    D.52870 = *D.52858;
    D.52871 = D.52870->data.op[1].vtype;
    D.52872 = mono_type_to_regmove (cfg, D.52871);
    D.52873 = (short unsigned int) D.52872;
    store->opcode = D.52873;
    D.52855 = cfg->locals;
    D.52856 = (long unsigned int) local;
    D.52857 = D.52856 * 8;
    D.52858 = D.52855 + D.52857;
    D.52870 = *D.52858;
    D.52874 = D.52870->klass;
    store->klass = D.52874;
    D.52875 = cfg->cbb;
    D.52876 = D.52875->last_ins;
    D.52877 = D.52876->dreg;
    store->sreg1 = D.52877;
    D.52855 = cfg->locals;
    D.52856 = (long unsigned int) local;
    D.52857 = D.52856 * 8;
    D.52858 = D.52855 + D.52857;
    D.52870 = *D.52858;
    D.52878 = D.52870->dreg;
    store->dreg = D.52878;
    D.52879 = store->opcode;
    if (D.52879 == 427) goto <D.52880>; else goto <D.52881>;
    <D.52880>:
    D.52855 = cfg->locals;
    D.52856 = (long unsigned int) local;
    D.52857 = D.52856 * 8;
    D.52858 = D.52855 + D.52857;
    D.52870 = *D.52858;
    D.52871 = D.52870->data.op[1].vtype;
    D.52882 = mono_class_from_mono_type (D.52871);
    store->klass = D.52882;
    <D.52881>:
    D.52875 = cfg->cbb;
    D.52876 = D.52875->last_ins;
    if (D.52876 != 0B) goto <D.52883>; else goto <D.52884>;
    <D.52883>:
    D.52875 = cfg->cbb;
    D.52876 = D.52875->last_ins;
    D.52876->next = store;
    D.52875 = cfg->cbb;
    D.52876 = D.52875->last_ins;
    store->prev = D.52876;
    D.52875 = cfg->cbb;
    D.52875->last_ins = store;
    goto <D.52885>;
    <D.52884>:
    D.52875 = cfg->cbb;
    D.52875 = cfg->cbb;
    D.52875->last_ins = store;
    D.52876 = D.52875->last_ins;
    D.52875->code = D.52876;
    <D.52885>:
  }
  goto <D.52886>;
  <D.52860>:
  D.52887 = var->dreg;
  emit_init_rvar (cfg, D.52887, type);
  <D.52886>:
}


emit_push_lmf (struct MonoCompile * cfg)
{
  long unsigned int D.52888;
  long unsigned int D.52889;
  long unsigned int D.52894;
  int D.52896;
  _Bool D.52898;
  long int D.52899;
  long int D.52900;
  struct MonoBasicBlock * D.52903;
  struct MonoInst * D.52904;
  struct MonoMemPool * D.52908;
  long int D.52909;
  struct MonoInst * D.52910;
  int D.52911;
  int D.52912;
  const unsigned char * D.52913;
  struct MonoInst * D.52914;
  unsigned char D.52915;
  unsigned char D.52916;
  struct MonoClass * D.52917;
  unsigned int D.52918;
  int D.52919;
  int D.52920;
  _Bool D.52921;
  long int D.52922;
  long int D.52923;
  struct MonoType * D.52926;
  int D.52927;
  struct MonoInst * iftmp.505;
  int D.52933;
  int D.52934;
  unsigned int D.52935;
  unsigned int D.52936;
  struct MonoInst * * D.52939;
  sizetype D.52940;
  sizetype D.52941;
  sizetype D.52942;
  struct MonoInst * * D.52943;
  struct MonoInst * iftmp.506;
  int D.52946;
  unsigned int D.52947;
  sizetype D.52950;
  sizetype D.52951;
  struct MonoInst * * D.52952;
  _Bool D.52954;
  long int D.52955;
  long int D.52956;
  _Bool D.52959;
  long int D.52960;
  long int D.52961;
  unsigned char D.52964;
  unsigned char D.52965;
  unsigned char D.52966;
  unsigned char D.52967;
  int D.52971;
  struct MonoInst * D.52975;
  struct MonoClass * D.52978;
  struct MonoType * D.52979;
  struct MonoInst * D.52980;
  int D.52987;
  unsigned int D.52988;
  int D.52989;
  int D.52992;
  struct MonoInst * iftmp.507;
  struct MonoInst * iftmp.508;
  _Bool D.53005;
  long int D.53006;
  long int D.53007;
  _Bool D.53010;
  long int D.53011;
  long int D.53012;
  unsigned char D.53015;
  unsigned char D.53016;
  unsigned char D.53017;
  unsigned char D.53018;
  unsigned int D.53022;
  int lmf_reg;
  int prev_lmf_reg;
  struct MonoInst * ins;
  struct MonoInst * lmf_ins;

  D.52888 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52889 = D.52888 & 288230376151711744;
  if (D.52889 == 0) goto <D.52890>; else goto <D.52891>;
  <D.52890>:
  return;
  <D.52891>:
  D.52888 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.52894 = D.52888 & 576460752303423488;
  if (D.52894 != 0) goto <D.52895>; else goto <D.52892>;
  <D.52895>:
  D.52896 = mini_tls_get_supported (cfg, 3);
  if (D.52896 != 0) goto <D.52897>; else goto <D.52892>;
  <D.52897>:
  lmf_ins = mono_get_lmf_intrinsic (cfg);
  D.52898 = lmf_ins == 0B;
  D.52899 = (long int) D.52898;
  D.52900 = __builtin_expect (D.52899, 0);
  if (D.52900 != 0) goto <D.52901>; else goto <D.52902>;
  <D.52901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1922, "lmf_ins");
  <D.52902>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.52905>; else goto <D.52906>;
  <D.52905>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = lmf_ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  lmf_ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = lmf_ins;
  goto <D.52907>;
  <D.52906>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = lmf_ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.52907>:
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  D.52914 = cfg->lmf_var;
  ins->data.op[0].p = D.52914;
  D.52914 = cfg->lmf_var;
  D.52914 = cfg->lmf_var;
  D.52915 = D.52914->flags;
  D.52916 = D.52915 | 16;
  D.52914->flags = D.52916;
  ins->type = 5;
  D.52914 = cfg->lmf_var;
  D.52917 = D.52914->klass;
  ins->klass = D.52917;
  D.52918 = alloc_dreg (cfg, 5);
  D.52919 = (int) D.52918;
  ins->dreg = D.52919;
  cfg->has_indirection = 1;
  D.52920 = cfg->gsharedvt;
  D.52921 = D.52920 != 0;
  D.52922 = (long int) D.52921;
  D.52923 = __builtin_expect (D.52922, 0);
  if (D.52923 != 0) goto <D.52924>; else goto <D.52925>;
  <D.52924>:
  D.52914 = cfg->lmf_var;
  D.52926 = D.52914->data.op[1].vtype;
  D.52927 = mini_is_gsharedvt_variable_type (cfg, D.52926);
  if (D.52927 != 0) goto <D.52928>; else goto <D.52929>;
  <D.52928>:
  handle_gsharedvt_ldaddr (cfg);
  <D.52929>:
  <D.52925>:
  if (0 != 0) goto <D.52930>; else goto <D.52931>;
  <D.52930>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52934 = D.52933 + 1;
    D.52935 = (unsigned int) D.52934;
    D.52936 = cfg->vreg_to_inst_len;
    if (D.52935 < D.52936) goto <D.52937>; else goto <D.52938>;
    <D.52937>:
    D.52939 = cfg->vreg_to_inst;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52940 = (sizetype) D.52933;
    D.52941 = D.52940 + 1;
    D.52942 = D.52941 * 8;
    D.52943 = D.52939 + D.52942;
    iftmp.505 = *D.52943;
    goto <D.52944>;
    <D.52938>:
    iftmp.505 = 0B;
    <D.52944>:
    var1 = iftmp.505;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52946 = D.52933 + 2;
    D.52947 = (unsigned int) D.52946;
    D.52936 = cfg->vreg_to_inst_len;
    if (D.52947 < D.52936) goto <D.52948>; else goto <D.52949>;
    <D.52948>:
    D.52939 = cfg->vreg_to_inst;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52940 = (sizetype) D.52933;
    D.52950 = D.52940 + 2;
    D.52951 = D.52950 * 8;
    D.52952 = D.52939 + D.52951;
    iftmp.506 = *D.52952;
    goto <D.52953>;
    <D.52949>:
    iftmp.506 = 0B;
    <D.52953>:
    var2 = iftmp.506;
    D.52954 = var1 == 0B;
    D.52955 = (long int) D.52954;
    D.52956 = __builtin_expect (D.52955, 0);
    if (D.52956 != 0) goto <D.52957>; else goto <D.52958>;
    <D.52957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1924, "var1");
    <D.52958>:
    D.52959 = var2 == 0B;
    D.52960 = (long int) D.52959;
    D.52961 = __builtin_expect (D.52960, 0);
    if (D.52961 != 0) goto <D.52962>; else goto <D.52963>;
    <D.52962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1924, "var2");
    <D.52963>:
    D.52964 = var1->flags;
    D.52965 = D.52964 | 16;
    var1->flags = D.52965;
    D.52966 = var2->flags;
    D.52967 = D.52966 | 16;
    var2->flags = D.52967;
  }
  <D.52931>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.52968>; else goto <D.52969>;
  <D.52968>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.52970>;
  <D.52969>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.52970>:
  lmf_reg = ins->dreg;
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  D.52971 = lmf_ins->dreg;
  ins->sreg1 = D.52971;
  ins->dreg = lmf_reg;
  ins->data.op[0].const_val = 0;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.52972>; else goto <D.52973>;
  <D.52972>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.52974>;
  <D.52973>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.52974>:
  emit_tls_set (cfg, lmf_reg, 3);
  goto <D.52893>;
  <D.52892>:
  D.52975 = cfg->lmf_addr_var;
  if (D.52975 == 0B) goto <D.52976>; else goto <D.52977>;
  <D.52976>:
  D.52978 = mono_defaults.int_class;
  D.52979 = &D.52978->byval_arg;
  D.52980 = mono_compile_create_var (cfg, D.52979, 329);
  cfg->lmf_addr_var = D.52980;
  <D.52977>:
  lmf_ins = mono_get_lmf_addr_intrinsic (cfg);
  if (lmf_ins != 0B) goto <D.52981>; else goto <D.52982>;
  <D.52981>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.52983>; else goto <D.52984>;
  <D.52983>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = lmf_ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  lmf_ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = lmf_ins;
  goto <D.52985>;
  <D.52984>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = lmf_ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.52985>:
  goto <D.52986>;
  <D.52982>:
  lmf_ins = mono_emit_jit_icall (cfg, mono_get_lmf_addr, 0B);
  <D.52986>:
  D.52975 = cfg->lmf_addr_var;
  D.52987 = D.52975->dreg;
  lmf_ins->dreg = D.52987;
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  D.52914 = cfg->lmf_var;
  ins->data.op[0].p = D.52914;
  D.52914 = cfg->lmf_var;
  D.52914 = cfg->lmf_var;
  D.52915 = D.52914->flags;
  D.52916 = D.52915 | 16;
  D.52914->flags = D.52916;
  ins->type = 5;
  D.52914 = cfg->lmf_var;
  D.52917 = D.52914->klass;
  ins->klass = D.52917;
  D.52988 = alloc_dreg (cfg, 5);
  D.52989 = (int) D.52988;
  ins->dreg = D.52989;
  cfg->has_indirection = 1;
  D.52920 = cfg->gsharedvt;
  D.52921 = D.52920 != 0;
  D.52922 = (long int) D.52921;
  D.52923 = __builtin_expect (D.52922, 0);
  if (D.52923 != 0) goto <D.52990>; else goto <D.52991>;
  <D.52990>:
  D.52914 = cfg->lmf_var;
  D.52926 = D.52914->data.op[1].vtype;
  D.52992 = mini_is_gsharedvt_variable_type (cfg, D.52926);
  if (D.52992 != 0) goto <D.52993>; else goto <D.52994>;
  <D.52993>:
  handle_gsharedvt_ldaddr (cfg);
  <D.52994>:
  <D.52991>:
  if (0 != 0) goto <D.52995>; else goto <D.52996>;
  <D.52995>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52934 = D.52933 + 1;
    D.52935 = (unsigned int) D.52934;
    D.52936 = cfg->vreg_to_inst_len;
    if (D.52935 < D.52936) goto <D.52998>; else goto <D.52999>;
    <D.52998>:
    D.52939 = cfg->vreg_to_inst;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52940 = (sizetype) D.52933;
    D.52941 = D.52940 + 1;
    D.52942 = D.52941 * 8;
    D.52943 = D.52939 + D.52942;
    iftmp.507 = *D.52943;
    goto <D.53000>;
    <D.52999>:
    iftmp.507 = 0B;
    <D.53000>:
    var1 = iftmp.507;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52946 = D.52933 + 2;
    D.52947 = (unsigned int) D.52946;
    D.52936 = cfg->vreg_to_inst_len;
    if (D.52947 < D.52936) goto <D.53002>; else goto <D.53003>;
    <D.53002>:
    D.52939 = cfg->vreg_to_inst;
    D.52914 = cfg->lmf_var;
    D.52933 = D.52914->dreg;
    D.52940 = (sizetype) D.52933;
    D.52950 = D.52940 + 2;
    D.52951 = D.52950 * 8;
    D.52952 = D.52939 + D.52951;
    iftmp.508 = *D.52952;
    goto <D.53004>;
    <D.53003>:
    iftmp.508 = 0B;
    <D.53004>:
    var2 = iftmp.508;
    D.53005 = var1 == 0B;
    D.53006 = (long int) D.53005;
    D.53007 = __builtin_expect (D.53006, 0);
    if (D.53007 != 0) goto <D.53008>; else goto <D.53009>;
    <D.53008>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1944, "var1");
    <D.53009>:
    D.53010 = var2 == 0B;
    D.53011 = (long int) D.53010;
    D.53012 = __builtin_expect (D.53011, 0);
    if (D.53012 != 0) goto <D.53013>; else goto <D.53014>;
    <D.53013>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1944, "var2");
    <D.53014>:
    D.53015 = var1->flags;
    D.53016 = D.53015 | 16;
    var1->flags = D.53016;
    D.53017 = var2->flags;
    D.53018 = D.53017 | 16;
    var2->flags = D.53018;
  }
  <D.52996>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.53019>; else goto <D.53020>;
  <D.53019>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.53021>;
  <D.53020>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.53021>:
  lmf_reg = ins->dreg;
  D.53022 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.53022;
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  ins->dreg = prev_lmf_reg;
  D.52975 = cfg->lmf_addr_var;
  D.52987 = D.52975->dreg;
  ins->sreg1 = D.52987;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.53023>; else goto <D.53024>;
  <D.53023>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.53025>;
  <D.53024>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.53025>:
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  ins->sreg1 = prev_lmf_reg;
  ins->dreg = lmf_reg;
  ins->data.op[0].const_val = 0;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.53026>; else goto <D.53027>;
  <D.53026>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.53028>;
  <D.53027>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.53028>:
  D.52908 = cfg->mempool;
  ins = mono_mempool_alloc (D.52908, 80);
  ins->data.op[1].const_val = 0;
  D.52909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.52909;
  ins->prev = 0B;
  D.52910 = ins->prev;
  ins->next = D.52910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.52911 = ins->sreg3;
  ins->sreg2 = D.52911;
  D.52912 = ins->sreg2;
  ins->sreg1 = D.52912;
  D.52913 = cfg->ip;
  ins->cil_code = D.52913;
  ins->sreg1 = lmf_reg;
  D.52975 = cfg->lmf_addr_var;
  D.52987 = D.52975->dreg;
  ins->dreg = D.52987;
  ins->data.op[0].const_val = 0;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  if (D.52904 != 0B) goto <D.53029>; else goto <D.53030>;
  <D.53029>:
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  D.52904->next = ins;
  D.52903 = cfg->cbb;
  D.52904 = D.52903->last_ins;
  ins->prev = D.52904;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  goto <D.53031>;
  <D.53030>:
  D.52903 = cfg->cbb;
  D.52903 = cfg->cbb;
  D.52903->last_ins = ins;
  D.52904 = D.52903->last_ins;
  D.52903->code = D.52904;
  <D.53031>:
  <D.52893>:
}


mono_find_block_region (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.53033;
  long unsigned int D.53034;
  long unsigned int D.53035;
  unsigned int D.53036;
  unsigned int offset.509;
  unsigned int D.53040;
  unsigned int D.53043;
  int D.53046;
  int D.53047;
  int D.53048;
  unsigned int D.53049;
  unsigned int D.53050;
  unsigned int D.53051;
  unsigned int D.53054;
  unsigned int D.53055;
  unsigned int D.53060;
  unsigned int D.53063;
  unsigned int D.53064;
  unsigned int D.53065;
  unsigned int D.53068;
  unsigned int D.53069;
  <unnamed-unsigned:15> D.53072;
  int D.53073;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.25010>;
  <D.25009>:
  D.53033 = header->clauses;
  D.53034 = (long unsigned int) i;
  D.53035 = D.53034 * 32;
  clause = D.53033 + D.53035;
  D.53036 = clause->flags;
  if (D.53036 == 1) goto <D.53037>; else goto <D.53038>;
  <D.53037>:
  offset.509 = (unsigned int) offset;
  D.53040 = clause->data.filter_offset;
  if (offset.509 >= D.53040) goto <D.53041>; else goto <D.53042>;
  <D.53041>:
  offset.509 = (unsigned int) offset;
  D.53043 = clause->handler_offset;
  if (offset.509 < D.53043) goto <D.53044>; else goto <D.53045>;
  <D.53044>:
  D.53047 = i + 1;
  D.53048 = D.53047 << 8;
  D.53049 = (unsigned int) D.53048;
  D.53036 = clause->flags;
  D.53050 = D.53049 | D.53036;
  D.53051 = D.53050 | 128;
  D.53046 = (int) D.53051;
  return D.53046;
  <D.53045>:
  <D.53042>:
  <D.53038>:
  D.53043 = clause->handler_offset;
  offset.509 = (unsigned int) offset;
  if (D.53043 <= offset.509) goto <D.53052>; else goto <D.53053>;
  <D.53052>:
  offset.509 = (unsigned int) offset;
  D.53043 = clause->handler_offset;
  D.53054 = clause->handler_len;
  D.53055 = D.53043 + D.53054;
  if (offset.509 < D.53055) goto <D.53056>; else goto <D.53057>;
  <D.53056>:
  D.53036 = clause->flags;
  if (D.53036 == 2) goto <D.53058>; else goto <D.53059>;
  <D.53058>:
  D.53047 = i + 1;
  D.53048 = D.53047 << 8;
  D.53049 = (unsigned int) D.53048;
  D.53036 = clause->flags;
  D.53050 = D.53049 | D.53036;
  D.53060 = D.53050 | 16;
  D.53046 = (int) D.53060;
  return D.53046;
  <D.53059>:
  D.53036 = clause->flags;
  if (D.53036 == 4) goto <D.53061>; else goto <D.53062>;
  <D.53061>:
  D.53047 = i + 1;
  D.53048 = D.53047 << 8;
  D.53049 = (unsigned int) D.53048;
  D.53036 = clause->flags;
  D.53050 = D.53049 | D.53036;
  D.53063 = D.53050 | 64;
  D.53046 = (int) D.53063;
  return D.53046;
  <D.53062>:
  D.53047 = i + 1;
  D.53048 = D.53047 << 8;
  D.53049 = (unsigned int) D.53048;
  D.53036 = clause->flags;
  D.53050 = D.53049 | D.53036;
  D.53064 = D.53050 | 32;
  D.53046 = (int) D.53064;
  return D.53046;
  <D.53057>:
  <D.53053>:
  D.53065 = clause->try_offset;
  offset.509 = (unsigned int) offset;
  if (D.53065 <= offset.509) goto <D.53066>; else goto <D.53067>;
  <D.53066>:
  offset.509 = (unsigned int) offset;
  D.53065 = clause->try_offset;
  D.53068 = clause->try_len;
  D.53069 = D.53065 + D.53068;
  if (offset.509 < D.53069) goto <D.53070>; else goto <D.53071>;
  <D.53070>:
  D.53047 = i + 1;
  D.53048 = D.53047 << 8;
  D.53049 = (unsigned int) D.53048;
  D.53036 = clause->flags;
  D.53050 = D.53049 | D.53036;
  D.53046 = (int) D.53050;
  return D.53046;
  <D.53071>:
  <D.53067>:
  i = i + 1;
  <D.25010>:
  D.53072 = header->num_clauses;
  D.53073 = (int) D.53072;
  if (D.53073 > i) goto <D.25009>; else goto <D.25011>;
  <D.25011>:
  D.53046 = -1;
  return D.53046;
}


mono_create_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct GHashTable * D.53075;
  long int D.53076;
  const void * D.53077;
  struct MonoClass * D.53080;
  struct MonoType * D.53081;
  unsigned char D.53082;
  unsigned char D.53083;
  void * D.53084;
  struct MonoInst * var;

  D.53075 = cfg->spvars;
  D.53076 = (long int) region;
  D.53077 = (const void *) D.53076;
  var = monoeg_g_hash_table_lookup (D.53075, D.53077);
  if (var != 0B) goto <D.53078>; else goto <D.53079>;
  <D.53078>:
  return;
  <D.53079>:
  D.53080 = mono_defaults.int_class;
  D.53081 = &D.53080->byval_arg;
  var = mono_compile_create_var (cfg, D.53081, 329);
  D.53082 = var->flags;
  D.53083 = D.53082 | 4;
  var->flags = D.53083;
  D.53075 = cfg->spvars;
  D.53076 = (long int) region;
  D.53084 = (void *) D.53076;
  monoeg_g_hash_table_insert_replace (D.53075, D.53084, var, 0);
}


set_exception_type_from_invalid_il (struct MonoCompile * cfg, struct MonoMethod * method, unsigned char * ip)
{
  unsigned int D.53086;
  gchar * D.53090;
  struct MonoMemPool * D.53091;
  struct GSList * D.53092;
  struct GSList * D.53093;
  char * method_fname;
  char * method_code;
  struct MonoMethodHeader * header;

  method_fname = mono_method_full_name (method, 1);
  header = mono_method_get_header (method);
  D.53086 = header->code_size;
  if (D.53086 == 0) goto <D.53087>; else goto <D.53088>;
  <D.53087>:
  method_code = monoeg_strdup ("method body is empty.");
  goto <D.53089>;
  <D.53088>:
  method_code = mono_disasm_code_one (0B, method, ip, 0B);
  <D.53089>:
  mono_cfg_set_exception (cfg, 3);
  D.53090 = monoeg_g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
  cfg->exception_message = D.53090;
  monoeg_g_free (method_fname);
  monoeg_g_free (method_code);
  D.53091 = cfg->mempool;
  D.53092 = cfg->headers_to_free;
  D.53093 = g_slist_prepend_mempool (D.53091, D.53092, header);
  cfg->headers_to_free = D.53093;
}


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

  if (str != 0B) goto <D.53094>; else goto <D.53095>;
  <D.53094>:
  D.53096 = __strdup (str);
  return D.53096;
  <D.53095>:
  D.53096 = 0B;
  return D.53096;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.53098;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = list;
  D.53098 = new_list;
  return D.53098;
}


mono_op_to_op_imm (int opcode)
{
  int D.53100;

  switch (opcode) <default: <D.53101>, case 322: <D.28828>, case 325: <D.28830>, case 326: <D.28829>, case 338: <D.28839>, case 344: <D.28835>, case 347: <D.28836>, case 350: <D.28838>, case 353: <D.28837>, case 374: <D.28831>, case 375: <D.28832>, case 376: <D.28833>, case 377: <D.28834>, case 479: <D.28820>, case 480: <D.28821>, case 486: <D.28822>, case 487: <D.28823>, case 488: <D.28824>, case 489: <D.28825>, case 490: <D.28826>, case 491: <D.28827>, case 565: <D.28807>, case 566: <D.28808>, case 567: <D.28813>, case 568: <D.28809>, case 569: <D.28810>, case 570: <D.28811>, case 571: <D.28812>, case 572: <D.28814>, case 573: <D.28815>, case 574: <D.28816>, case 575: <D.28817>, case 576: <D.28818>, case 577: <D.28819>>
  <D.28807>:
  D.53100 = 625;
  return D.53100;
  <D.28808>:
  D.53100 = 626;
  return D.53100;
  <D.28809>:
  D.53100 = 628;
  return D.53100;
  <D.28810>:
  D.53100 = 629;
  return D.53100;
  <D.28811>:
  D.53100 = 630;
  return D.53100;
  <D.28812>:
  D.53100 = 631;
  return D.53100;
  <D.28813>:
  D.53100 = 627;
  return D.53100;
  <D.28814>:
  D.53100 = 632;
  return D.53100;
  <D.28815>:
  D.53100 = 633;
  return D.53100;
  <D.28816>:
  D.53100 = 634;
  return D.53100;
  <D.28817>:
  D.53100 = 635;
  return D.53100;
  <D.28818>:
  D.53100 = 636;
  return D.53100;
  <D.28819>:
  D.53100 = 637;
  return D.53100;
  <D.28820>:
  D.53100 = 538;
  return D.53100;
  <D.28821>:
  D.53100 = 539;
  return D.53100;
  <D.28822>:
  D.53100 = 541;
  return D.53100;
  <D.28823>:
  D.53100 = 542;
  return D.53100;
  <D.28824>:
  D.53100 = 543;
  return D.53100;
  <D.28825>:
  D.53100 = 544;
  return D.53100;
  <D.28826>:
  D.53100 = 545;
  return D.53100;
  <D.28827>:
  D.53100 = 546;
  return D.53100;
  <D.28828>:
  D.53100 = 323;
  return D.53100;
  <D.28829>:
  D.53100 = 327;
  return D.53100;
  <D.28830>:
  D.53100 = 328;
  return D.53100;
  <D.28831>:
  D.53100 = 381;
  return D.53100;
  <D.28832>:
  D.53100 = 382;
  return D.53100;
  <D.28833>:
  D.53100 = 383;
  return D.53100;
  <D.28834>:
  D.53100 = 384;
  return D.53100;
  <D.28835>:
  D.53100 = 343;
  return D.53100;
  <D.28836>:
  D.53100 = 346;
  return D.53100;
  <D.28837>:
  D.53100 = 352;
  return D.53100;
  <D.28838>:
  D.53100 = 349;
  return D.53100;
  <D.28839>:
  D.53100 = 339;
  return D.53100;
  <D.53101>:
  D.53100 = -1;
  return D.53100;
}


mono_load_membase_to_load_mem (int opcode)
{
  int D.53103;

  D.53103 = -1;
  return D.53103;
}


mono_op_to_op_imm_noemul (int opcode)
{
  int D.53105;

  switch (opcode) <default: <D.28889>>
  <D.28889>:
  D.53105 = mono_op_to_op_imm (opcode);
  return D.53105;
}


mono_handle_global_vregs (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.53107;
  unsigned int D.53108;
  unsigned int D.53109;
  unsigned int D.53110;
  unsigned int D.53111;
  int D.53114;
  short unsigned int D.53115;
  int D.53116;
  int D.53117;
  int D.53118;
  _Bool D.53119;
  long int D.53120;
  long int D.53121;
  _Bool D.53124;
  long int D.53125;
  long int D.53126;
  char D.53131;
  const char * D.53137;
  char D.53138;
  const char * D.53144;
  char D.53145;
  const char * D.53151;
  char D.53152;
  _Bool D.53155;
  long int D.53156;
  long int D.53157;
  long unsigned int D.53160;
  long unsigned int D.53161;
  gint32 * D.53162;
  int D.53165;
  unsigned int vreg.510;
  unsigned int D.53178;
  struct MonoInst * * D.53180;
  long unsigned int D.53181;
  struct MonoInst * * D.53182;
  struct MonoInst * D.53183;
  int D.53186;
  unsigned int D.53189;
  gboolean * D.53191;
  gboolean * D.53192;
  int D.53193;
  struct MonoClass * D.53195;
  struct MonoType * D.53196;
  struct MonoClass * D.53197;
  struct MonoType * D.53198;
  struct MonoClass * D.53199;
  struct MonoType * D.53200;
  struct MonoClass * D.53201;
  struct MonoType * D.53202;
  struct MonoClass * D.53203;
  struct MonoType * D.53204;
  struct MonoInst * * D.53205;
  long unsigned int D.53206;
  long unsigned int D.53207;
  struct MonoInst * * D.53208;
  struct MonoMethodVar * D.53209;
  long unsigned int D.53210;
  unsigned char D.53211;
  int D.53212;
  int D.53213;
  short unsigned int D.53215;
  struct MonoInst * D.53218;
  unsigned char D.53221;
  int D.53222;
  int D.53223;
  int D.53226;
  long unsigned int D.53227;
  long unsigned int D.53228;
  gint32 * D.53229;
  int D.53230;
  struct MonoClass * D.53233;
  unsigned char D.53234;
  long unsigned int D.53237;
  long unsigned int D.53238;
  struct MonoInst * D.53241;
  struct MonoInst * D.53244;
  struct MonoInst * D.53247;
  unsigned int D.53252;
  unsigned char D.53253;
  long unsigned int D.53254;
  struct MonoInst * * D.53255;
  unsigned int i.511;
  unsigned int D.53258;
  unsigned int D.53261;
  unsigned int pos.512;
  unsigned char D.53265;
  int D.53266;
  int D.53267;
  long unsigned int D.53272;
  long unsigned int D.53273;
  struct MonoInst * * D.53274;
  struct MonoInst * D.53275;
  struct MonoInst * D.53276;
  long int D.53277;
  long unsigned int D.53278;
  struct MonoMethodVar * D.53279;
  struct MonoMethodVar * D.53280;
  gint32 * vreg_to_bb;
  struct MonoBasicBlock * bb;
  int i;
  int pos;

  D.53107 = cfg->mempool;
  D.53108 = cfg->next_vreg;
  D.53109 = D.53108 * 8;
  D.53110 = D.53109 + 1;
  vreg_to_bb = mono_mempool_alloc0 (D.53107, D.53110);
  bb = cfg->bb_entry;
  goto <D.28918>;
  <D.28917>:
  {
    struct MonoInst * ins;
    int block_num;

    ins = bb->code;
    block_num = bb->block_num;
    D.53111 = cfg->verbose_level;
    if (D.53111 > 2) goto <D.53112>; else goto <D.53113>;
    <D.53112>:
    D.53114 = bb->block_num;
    printf ("\nHANDLE-GLOBAL-VREGS BLOCK %d:\n", D.53114);
    <D.53113>:
    cfg->cbb = bb;
    goto <D.28915>;
    <D.28914>:
    {
      const char * spec;
      int regtype;
      int regindex;
      gint32 prev_bb;

      D.53115 = ins->opcode;
      D.53116 = (int) D.53115;
      D.53117 = D.53116 + -313;
      D.53118 = D.53117 * 4;
      spec = &ins_info[D.53118];
      regtype = 0;
      D.53111 = cfg->verbose_level;
      D.53119 = D.53111 > 2;
      D.53120 = (long int) D.53119;
      D.53121 = __builtin_expect (D.53120, 0);
      if (D.53121 != 0) goto <D.53122>; else goto <D.53123>;
      <D.53122>:
      mono_print_ins (ins);
      <D.53123>:
      D.53115 = ins->opcode;
      D.53124 = D.53115 <= 312;
      D.53125 = (long int) D.53124;
      D.53126 = __builtin_expect (D.53125, 0);
      if (D.53126 != 0) goto <D.53127>; else goto <D.53128>;
      <D.53127>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12539, "ins->opcode >= MONO_CEE_LAST");
      <D.53128>:
      regindex = 0;
      goto <D.28912>;
      <D.28911>:
      {
        int vreg;

        vreg = 0;
        if (regindex == 0) goto <D.53129>; else goto <D.53130>;
        <D.53129>:
        D.53131 = *spec;
        regtype = (int) D.53131;
        if (regtype == 32) goto <D.53132>; else goto <D.53133>;
        <D.53132>:
        // predicted unlikely by continue predictor.
        goto <D.28904>;
        <D.53133>:
        vreg = ins->dreg;
        goto <D.53134>;
        <D.53130>:
        if (regindex == 1) goto <D.53135>; else goto <D.53136>;
        <D.53135>:
        D.53137 = spec + 1;
        D.53138 = *D.53137;
        regtype = (int) D.53138;
        if (regtype == 32) goto <D.53139>; else goto <D.53140>;
        <D.53139>:
        // predicted unlikely by continue predictor.
        goto <D.28904>;
        <D.53140>:
        vreg = ins->sreg1;
        goto <D.53141>;
        <D.53136>:
        if (regindex == 2) goto <D.53142>; else goto <D.53143>;
        <D.53142>:
        D.53144 = spec + 2;
        D.53145 = *D.53144;
        regtype = (int) D.53145;
        if (regtype == 32) goto <D.53146>; else goto <D.53147>;
        <D.53146>:
        // predicted unlikely by continue predictor.
        goto <D.28904>;
        <D.53147>:
        vreg = ins->sreg2;
        goto <D.53148>;
        <D.53143>:
        if (regindex == 3) goto <D.53149>; else goto <D.53150>;
        <D.53149>:
        D.53151 = spec + 3;
        D.53152 = *D.53151;
        regtype = (int) D.53152;
        if (regtype == 32) goto <D.53153>; else goto <D.53154>;
        <D.53153>:
        // predicted unlikely by continue predictor.
        goto <D.28904>;
        <D.53154>:
        vreg = ins->sreg3;
        <D.53150>:
        <D.53148>:
        <D.53141>:
        <D.53134>:
        D.53155 = vreg == -1;
        D.53156 = (long int) D.53155;
        D.53157 = __builtin_expect (D.53156, 0);
        if (D.53157 != 0) goto <D.53158>; else goto <D.53159>;
        <D.53158>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12590, "vreg != -1");
        <D.53159>:
        D.53160 = (long unsigned int) vreg;
        D.53161 = D.53160 * 4;
        D.53162 = vreg_to_bb + D.53161;
        prev_bb = *D.53162;
        if (prev_bb == 0) goto <D.53163>; else goto <D.53164>;
        <D.53163>:
        D.53160 = (long unsigned int) vreg;
        D.53161 = D.53160 * 4;
        D.53162 = vreg_to_bb + D.53161;
        D.53165 = block_num + 1;
        *D.53162 = D.53165;
        goto <D.53166>;
        <D.53164>:
        D.53165 = block_num + 1;
        if (D.53165 != prev_bb) goto <D.53167>; else goto <D.53168>;
        <D.53167>:
        if (prev_bb != -1) goto <D.53169>; else goto <D.53170>;
        <D.53169>:
        if (regtype == 105) goto <D.53171>; else goto <D.53173>;
        <D.53173>:
        if (regtype == 102) goto <D.53171>; else goto <D.53172>;
        <D.53171>:
        if (vreg <= 31) goto <D.53174>; else goto <D.53175>;
        <D.53174>:
        // predicted unlikely by continue predictor.
        goto <D.28904>;
        <D.53175>:
        <D.53172>:
        vreg.510 = (unsigned int) vreg;
        D.53178 = cfg->vreg_to_inst_len;
        if (vreg.510 >= D.53178) goto <D.53176>; else goto <D.53179>;
        <D.53179>:
        D.53180 = cfg->vreg_to_inst;
        D.53160 = (long unsigned int) vreg;
        D.53181 = D.53160 * 8;
        D.53182 = D.53180 + D.53181;
        D.53183 = *D.53182;
        if (D.53183 == 0B) goto <D.53176>; else goto <D.28906>;
        <D.53176>:
        D.53111 = cfg->verbose_level;
        D.53119 = D.53111 > 2;
        D.53120 = (long int) D.53119;
        D.53121 = __builtin_expect (D.53120, 0);
        if (D.53121 != 0) goto <D.53184>; else goto <D.53185>;
        <D.53184>:
        D.53160 = (long unsigned int) vreg;
        D.53161 = D.53160 * 4;
        D.53162 = vreg_to_bb + D.53161;
        D.53186 = *D.53162;
        printf ("VREG R%d used in BB%d and BB%d made global.\n", vreg, D.53186, block_num);
        <D.53185>:
        switch (regtype) <default: <D.28910>, case 102: <D.28908>, case 105: <D.28905>, case 108: <D.28907>, case 118: <D.28909>>
        <D.28905>:
        vreg.510 = (unsigned int) vreg;
        D.53189 = cfg->vreg_is_ref_len;
        if (vreg.510 < D.53189) goto <D.53190>; else goto <D.53187>;
        <D.53190>:
        D.53191 = cfg->vreg_is_ref;
        D.53160 = (long unsigned int) vreg;
        D.53161 = D.53160 * 4;
        D.53192 = D.53191 + D.53161;
        D.53193 = *D.53192;
        if (D.53193 != 0) goto <D.53194>; else goto <D.53187>;
        <D.53194>:
        D.53195 = mono_defaults.object_class;
        D.53196 = &D.53195->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.53196, 329, vreg);
        goto <D.53188>;
        <D.53187>:
        D.53197 = mono_defaults.int_class;
        D.53198 = &D.53197->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.53198, 329, vreg);
        <D.53188>:
        goto <D.28906>;
        <D.28907>:
        D.53199 = mono_defaults.int64_class;
        D.53200 = &D.53199->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.53200, 329, vreg);
        goto <D.28906>;
        <D.28908>:
        D.53201 = mono_defaults.double_class;
        D.53202 = &D.53201->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.53202, 329, vreg);
        goto <D.28906>;
        <D.28909>:
        D.53203 = ins->klass;
        D.53204 = &D.53203->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.53204, 329, vreg);
        goto <D.28906>;
        <D.28910>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12621);
        <D.28906>:
        D.53160 = (long unsigned int) vreg;
        D.53161 = D.53160 * 4;
        D.53162 = vreg_to_bb + D.53161;
        *D.53162 = -1;
        <D.53170>:
        <D.53168>:
        <D.53166>:
      }
      <D.28904>:
      regindex = regindex + 1;
      <D.28912>:
      if (regindex <= 3) goto <D.28911>; else goto <D.28913>;
      <D.28913>:
    }
    ins = ins->next;
    <D.28915>:
    if (ins != 0B) goto <D.28914>; else goto <D.28916>;
    <D.28916>:
  }
  bb = bb->next_bb;
  <D.28918>:
  if (bb != 0B) goto <D.28917>; else goto <D.28919>;
  <D.28919>:
  i = 0;
  goto <D.28931>;
  <D.28930>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * vmv;

    D.53205 = cfg->varinfo;
    D.53206 = (long unsigned int) i;
    D.53207 = D.53206 * 8;
    D.53208 = D.53205 + D.53207;
    var = *D.53208;
    D.53209 = cfg->vars;
    D.53206 = (long unsigned int) i;
    D.53210 = D.53206 * 80;
    vmv = D.53209 + D.53210;
    D.53211 = var->type;
    D.53212 = (int) D.53211;
    switch (D.53212) <default: <D.53256>, case 1: <D.28922>, case 2: <D.28927>, case 3: <D.28924>, case 4: <D.28928>, case 5: <D.28925>, case 6: <D.28923>, case 7: <D.28926>>
    <D.28922>:
    <D.28923>:
    <D.28924>:
    <D.28925>:
    <D.28926>:
    <D.28927>:
    <D.28928>:
    D.53213 = mono_arch_is_soft_float ();
    if (D.53213 != 0) goto <D.28929>; else goto <D.53214>;
    <D.53214>:
    D.53215 = var->opcode;
    if (D.53215 != 330) goto <D.53216>; else goto <D.53217>;
    <D.53216>:
    D.53218 = cfg->ret;
    if (D.53218 != var) goto <D.53219>; else goto <D.53220>;
    <D.53219>:
    D.53221 = var->flags;
    D.53222 = (int) D.53221;
    D.53223 = D.53222 & 20;
    if (D.53223 == 0) goto <D.53224>; else goto <D.53225>;
    <D.53224>:
    D.53226 = var->dreg;
    D.53227 = (long unsigned int) D.53226;
    D.53228 = D.53227 * 4;
    D.53229 = vreg_to_bb + D.53228;
    D.53230 = *D.53229;
    if (D.53230 != -1) goto <D.53231>; else goto <D.53232>;
    <D.53231>:
    D.53233 = var->klass;
    D.53234 = D.53233->byval_arg.type;
    if (D.53234 != 12) goto <D.53235>; else goto <D.53236>;
    <D.53235>:
    D.53237 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.53238 = D.53237 & 18014398509481984;
    if (D.53238 == 0) goto <D.53239>; else goto <D.53240>;
    <D.53239>:
    D.53241 = cfg->gsharedvt_info_var;
    if (D.53241 != var) goto <D.53242>; else goto <D.53243>;
    <D.53242>:
    D.53244 = cfg->gsharedvt_locals_var;
    if (D.53244 != var) goto <D.53245>; else goto <D.53246>;
    <D.53245>:
    D.53247 = cfg->lmf_addr_var;
    if (D.53247 != var) goto <D.53248>; else goto <D.53249>;
    <D.53248>:
    D.53111 = cfg->verbose_level;
    D.53119 = D.53111 > 2;
    D.53120 = (long int) D.53119;
    D.53121 = __builtin_expect (D.53120, 0);
    if (D.53121 != 0) goto <D.53250>; else goto <D.53251>;
    <D.53250>:
    D.53226 = var->dreg;
    D.53252 = vmv->idx;
    printf ("CONVERTED R%d(%d) TO VREG.\n", D.53226, D.53252);
    <D.53251>:
    D.53221 = var->flags;
    D.53253 = D.53221 | 2;
    var->flags = D.53253;
    D.53180 = cfg->vreg_to_inst;
    D.53226 = var->dreg;
    D.53227 = (long unsigned int) D.53226;
    D.53254 = D.53227 * 8;
    D.53255 = D.53180 + D.53254;
    *D.53255 = 0B;
    <D.53249>:
    <D.53246>:
    <D.53243>:
    <D.53240>:
    <D.53236>:
    <D.53232>:
    <D.53225>:
    <D.53220>:
    <D.53217>:
    goto <D.28929>;
    <D.53256>:
    <D.28929>:
  }
  i = i + 1;
  <D.28931>:
  i.511 = (unsigned int) i;
  D.53258 = cfg->num_varinfo;
  if (i.511 < D.53258) goto <D.28930>; else goto <D.28932>;
  <D.28932>:
  pos = 0;
  i = 0;
  goto <D.28935>;
  <D.28934>:
  {
    struct MonoInst * var;

    D.53205 = cfg->varinfo;
    D.53206 = (long unsigned int) i;
    D.53207 = D.53206 * 8;
    D.53208 = D.53205 + D.53207;
    var = *D.53208;
    if (pos < i) goto <D.53259>; else goto <D.53260>;
    <D.53259>:
    D.53261 = cfg->locals_start;
    i.511 = (unsigned int) i;
    if (D.53261 == i.511) goto <D.53262>; else goto <D.53263>;
    <D.53262>:
    pos.512 = (unsigned int) pos;
    cfg->locals_start = pos.512;
    <D.53263>:
    <D.53260>:
    D.53265 = var->flags;
    D.53266 = (int) D.53265;
    D.53267 = D.53266 & 2;
    if (D.53267 == 0) goto <D.53268>; else goto <D.53269>;
    <D.53268>:
    if (pos < i) goto <D.53270>; else goto <D.53271>;
    <D.53270>:
    D.53205 = cfg->varinfo;
    D.53272 = (long unsigned int) pos;
    D.53273 = D.53272 * 8;
    D.53274 = D.53205 + D.53273;
    D.53205 = cfg->varinfo;
    D.53206 = (long unsigned int) i;
    D.53207 = D.53206 * 8;
    D.53208 = D.53205 + D.53207;
    D.53275 = *D.53208;
    *D.53274 = D.53275;
    D.53205 = cfg->varinfo;
    D.53272 = (long unsigned int) pos;
    D.53273 = D.53272 * 8;
    D.53274 = D.53205 + D.53273;
    D.53276 = *D.53274;
    D.53277 = (long int) pos;
    D.53276->data.op[0].const_val = D.53277;
    D.53209 = cfg->vars;
    D.53272 = (long unsigned int) pos;
    D.53278 = D.53272 * 80;
    D.53279 = D.53209 + D.53278;
    D.53209 = cfg->vars;
    D.53206 = (long unsigned int) i;
    D.53210 = D.53206 * 80;
    D.53280 = D.53209 + D.53210;
    memcpy (D.53279, D.53280, 80);
    D.53209 = cfg->vars;
    D.53272 = (long unsigned int) pos;
    D.53278 = D.53272 * 80;
    D.53279 = D.53209 + D.53278;
    pos.512 = (unsigned int) pos;
    D.53279->idx = pos.512;
    <D.53271>:
    pos = pos + 1;
    <D.53269>:
  }
  i = i + 1;
  <D.28935>:
  i.511 = (unsigned int) i;
  D.53258 = cfg->num_varinfo;
  if (i.511 < D.53258) goto <D.28934>; else goto <D.28936>;
  <D.28936>:
  pos.512 = (unsigned int) pos;
  cfg->num_varinfo = pos.512;
  D.53261 = cfg->locals_start;
  D.53258 = cfg->num_varinfo;
  if (D.53261 > D.53258) goto <D.53281>; else goto <D.53282>;
  <D.53281>:
  D.53258 = cfg->num_varinfo;
  cfg->locals_start = D.53258;
  <D.53282>:
}


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

  D.53284 = __builtin_object_size (__dest, 0);
  D.53283 = __builtin___memcpy_chk (__dest, __src, __len, D.53284);
  return D.53283;
}


mono_spill_global_vars (struct MonoCompile * cfg, gboolean * need_local_opts)
{
  long unsigned int D.53286;
  long unsigned int D.53287;
  struct MonoInst * * D.53290;
  long unsigned int D.53291;
  long unsigned int D.53292;
  struct MonoInst * * D.53293;
  short unsigned int D.53294;
  unsigned char D.53297;
  unsigned char D.53298;
  unsigned int D.53299;
  int D.53300;
  unsigned int D.53303;
  long unsigned int D.53304;
  long unsigned int D.53305;
  struct MonoType * D.53306;
  int D.53307;
  unsigned int D.53310;
  int D.53313;
  long unsigned int D.53314;
  long unsigned int D.53315;
  int * D.53316;
  int D.53317;
  long int D.53318;
  struct MonoMemPool * D.53320;
  unsigned int D.53321;
  long unsigned int D.53322;
  unsigned int D.53323;
  int D.53326;
  long unsigned int D.53327;
  guint32 * D.53328;
  unsigned int D.53329;
  long unsigned int D.53330;
  long unsigned int D.53331;
  guint32 * D.53332;
  short unsigned int D.53333;
  int D.53334;
  int D.53335;
  int D.53336;
  _Bool D.53337;
  long int D.53338;
  long int D.53339;
  short unsigned int D.53346;
  short unsigned int D.53349;
  int D.53352;
  struct MonoInst * D.53354;
  short unsigned int D.53355;
  int D.53358;
  long int D.53359;
  int D.53365;
  long unsigned int D.53366;
  long unsigned int D.53367;
  int * D.53368;
  int D.53369;
  _Bool D.53371;
  long int D.53372;
  long int D.53373;
  int D.53376;
  long int D.53377;
  _Bool D.53382;
  long int D.53383;
  long int D.53384;
  _Bool D.53387;
  long int D.53388;
  long int D.53389;
  _Bool D.53392;
  long int D.53393;
  long int D.53394;
  short unsigned int D.53397;
  unsigned int D.53400;
  long int D.53401;
  struct MonoInst * D.53402;
  int D.53403;
  int D.53404;
  const unsigned char * D.53405;
  int D.53406;
  long int D.53407;
  unsigned int D.53412;
  long int D.53413;
  struct MonoInst * D.53414;
  int D.53415;
  int D.53416;
  long unsigned int D.53417;
  long unsigned int D.53418;
  long unsigned int D.53419;
  long int D.53420;
  unsigned int D.53421;
  short unsigned int D.53422;
  long int D.53425;
  struct MonoInst * D.53426;
  int D.53427;
  int D.53428;
  int D.53429;
  long int D.53430;
  int D.53434;
  _Bool D.53438;
  long int D.53439;
  long int D.53440;
  short unsigned int D.53445;
  int D.53448;
  char D.53449;
  char D.53450;
  short unsigned int D.53452;
  int D.53457;
  int D.53458;
  int D.53459;
  signed char D.53460;
  int D.53461;
  int iftmp.513;
  _Bool D.53469;
  long int D.53470;
  long int D.53471;
  unsigned int D.53476;
  unsigned int D.53477;
  struct MonoInst * * D.53480;
  long unsigned int D.53481;
  long unsigned int D.53482;
  struct MonoInst * * D.53483;
  struct MonoInst * D.53484;
  struct MonoInst * iftmp.514;
  struct MonoType * D.53491;
  unsigned int D.53492;
  short unsigned int D.53493;
  int D.53496;
  const char * D.53502;
  char D.53503;
  long unsigned int D.53505;
  guint32 * D.53506;
  unsigned int D.53507;
  int D.53509;
  _Bool D.53511;
  long int D.53512;
  long int D.53513;
  int D.53519;
  short unsigned int D.53520;
  int D.53521;
  long int D.53522;
  unsigned int D.53527;
  unsigned int D.53528;
  int D.53529;
  _Bool D.53530;
  long int D.53531;
  long int D.53532;
  long int D.53541;
  int D.53542;
  short unsigned int D.53543;
  short unsigned int D.53550;
  int D.53554;
  int D.53556;
  short unsigned int D.53557;
  long int D.53558;
  struct MonoInst * D.53559;
  int D.53560;
  int D.53561;
  unsigned char D.53562;
  int D.53563;
  int D.53564;
  long unsigned int D.53569;
  long unsigned int D.53570;
  struct MonoInst * * D.53571;
  struct MonoInst * D.53572;
  struct MonoBasicBlock * * D.53575;
  signed char D.53580;
  long int D.53583;
  struct MonoInst * D.53584;
  int D.53585;
  int D.53586;
  long int D.53587;
  int D.53588;
  sizetype D.53589;
  const char * D.53590;
  char D.53591;
  int iftmp.515;
  _Bool D.53599;
  long int D.53600;
  long int D.53601;
  unsigned int sreg.516;
  long unsigned int D.53609;
  long unsigned int D.53610;
  struct MonoInst * * D.53611;
  struct MonoInst * D.53612;
  struct MonoInst * iftmp.517;
  short unsigned int D.53619;
  int D.53622;
  struct MonoInst * * D.53623;
  struct MonoBasicBlock * * D.53624;
  unsigned char D.53629;
  signed char D.53630;
  long int D.53633;
  struct MonoInst * D.53634;
  int D.53635;
  int D.53636;
  long int D.53637;
  _Bool D.53638;
  long int D.53639;
  long int D.53640;
  struct MonoType * D.53643;
  _Bool D.53644;
  long int D.53645;
  long int D.53646;
  long unsigned int D.53649;
  guint32 * D.53650;
  unsigned int D.53651;
  _Bool D.53654;
  long int D.53655;
  long int D.53656;
  int D.53661;
  int load_opcode.518;
  int D.53666;
  int D.53668;
  short unsigned int D.53669;
  int D.53670;
  long int D.53671;
  int D.53675;
  int D.53677;
  short unsigned int D.53678;
  unsigned int D.53683;
  int D.53684;
  int D.53685;
  int D.53686;
  _Bool D.53691;
  long int D.53692;
  long int D.53693;
  long unsigned int D.53696;
  long unsigned int D.53697;
  guint32 * D.53698;
  _Bool D.53699;
  long int D.53700;
  long int D.53701;
  unsigned int lvregs_len.519;
  long unsigned int D.53705;
  long unsigned int D.53706;
  guint32 * D.53707;
  unsigned int D.53708;
  long int D.53709;
  struct MonoInst * D.53710;
  short unsigned int D.53711;
  int D.53712;
  int D.53713;
  long unsigned int D.53716;
  struct MonoInst * * D.53717;
  struct MonoBasicBlock * * D.53718;
  long int D.53725;
  struct MonoInst * D.53726;
  int D.53727;
  int D.53728;
  long int D.53729;
  _Bool D.53732;
  long int D.53733;
  long int D.53734;
  long unsigned int D.53737;
  long unsigned int D.53738;
  guint32 * D.53739;
  unsigned int lvregs_len.520;
  long unsigned int D.53743;
  long unsigned int D.53744;
  guint32 * D.53745;
  unsigned int prev_dreg.521;
  short unsigned int D.53752;
  short unsigned int D.53754;
  short unsigned int D.53756;
  short unsigned int D.53758;
  short unsigned int D.53760;
  short unsigned int D.53762;
  long unsigned int D.53768;
  long unsigned int D.53769;
  struct MonoBitSet * D.53772;
  struct MonoInst * D.53775;
  struct MonoMethodVar * D.53778;
  long unsigned int D.53779;
  int iftmp.522;
  int D.53783;
  unsigned int D.53784;
  long unsigned int D.53786;
  long unsigned int D.53787;
  struct MonoInst * * D.53788;
  struct MonoInst * D.53789;
  struct MonoInst * iftmp.523;
  unsigned char D.53795;
  int D.53796;
  int D.53797;
  _Bool D.53799;
  long int D.53800;
  long int D.53801;
  struct MonoBitSet * D.53804;
  unsigned int D.53805;
  long unsigned int D.53806;
  long unsigned int D.53807;
  int i.524;
  int D.53809;
  long unsigned int D.53810;
  long unsigned int D.53811;
  struct MonoInst * * D.53814;
  struct MonoInst * D.53815;
  struct MonoBasicBlock * * D.53818;
  long unsigned int D.53819;
  long unsigned int D.53820;
  long unsigned int D.53821;
  struct MonoInst * * D.53824;
  struct MonoInst * D.53825;
  struct MonoBasicBlock * * D.53826;
  struct MonoInst * D.53827;
  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.53286 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.53287 = D.53286 & 128;
      if (D.53287 != 0) goto <D.53288>; else goto <D.53289>;
      <D.53288>:
      i = 0;
      goto <D.28957>;
      <D.28956>:
      {
        struct MonoInst * ins;

        D.53290 = cfg->varinfo;
        D.53291 = (long unsigned int) i;
        D.53292 = D.53291 * 8;
        D.53293 = D.53290 + D.53292;
        ins = *D.53293;
        D.53294 = ins->opcode;
        if (D.53294 == 366) goto <D.53295>; else goto <D.53296>;
        <D.53295>:
        D.53297 = ins->flags;
        D.53298 = D.53297 | 128;
        ins->flags = D.53298;
        <D.53296>:
      }
      i = i + 1;
      <D.28957>:
      D.53299 = cfg->num_varinfo;
      if (D.53299 > i) goto <D.28956>; else goto <D.28958>;
      <D.28958>:
      <D.53289>:
      D.53300 = cfg->gsharedvt;
      if (D.53300 != 0) goto <D.53301>; else goto <D.53302>;
      <D.53301>:
      D.53303 = cfg->next_vreg;
      D.53304 = (long unsigned int) D.53303;
      D.53305 = D.53304 * 4;
      gsharedvt_vreg_to_idx = monoeg_malloc0 (D.53305);
      i = 0;
      goto <D.28962>;
      <D.28961>:
      {
        struct MonoInst * ins;
        int idx;

        D.53290 = cfg->varinfo;
        D.53291 = (long unsigned int) i;
        D.53292 = D.53291 * 8;
        D.53293 = D.53290 + D.53292;
        ins = *D.53293;
        D.53306 = ins->data.op[1].vtype;
        D.53307 = mini_is_gsharedvt_variable_type (cfg, D.53306);
        if (D.53307 != 0) goto <D.53308>; else goto <D.53309>;
        <D.53308>:
        D.53310 = cfg->locals_start;
        if (D.53310 <= i) goto <D.53311>; else goto <D.53312>;
        <D.53311>:
        D.53306 = ins->data.op[1].vtype;
        idx = get_gsharedvt_info_slot (cfg, D.53306, 21);
        D.53313 = ins->dreg;
        D.53314 = (long unsigned int) D.53313;
        D.53315 = D.53314 * 4;
        D.53316 = gsharedvt_vreg_to_idx + D.53315;
        D.53317 = idx + 1;
        *D.53316 = D.53317;
        ins->opcode = 331;
        D.53318 = (long int) idx;
        ins->data.op[1].const_val = D.53318;
        goto <D.53319>;
        <D.53312>:
        D.53313 = ins->dreg;
        D.53314 = (long unsigned int) D.53313;
        D.53315 = D.53314 * 4;
        D.53316 = gsharedvt_vreg_to_idx + D.53315;
        *D.53316 = -1;
        ins->opcode = 332;
        <D.53319>:
        <D.53309>:
      }
      i = i + 1;
      <D.28962>:
      D.53299 = cfg->num_varinfo;
      if (D.53299 > i) goto <D.28961>; else goto <D.28963>;
      <D.28963>:
      <D.53302>:
      D.53303 = cfg->next_vreg;
      orig_next_vreg = (int) D.53303;
      D.53320 = cfg->mempool;
      D.53303 = cfg->next_vreg;
      D.53321 = D.53303 * 4;
      vreg_to_lvreg = mono_mempool_alloc0 (D.53320, D.53321);
      D.53320 = cfg->mempool;
      lvregs = mono_mempool_alloc (D.53320, 4096);
      lvregs_len = 0;
      D.53303 = cfg->next_vreg;
      D.53304 = (long unsigned int) D.53303;
      D.53322 = D.53304 * 8;
      live_range_start = monoeg_malloc0 (D.53322);
      D.53303 = cfg->next_vreg;
      D.53304 = (long unsigned int) D.53303;
      D.53322 = D.53304 * 8;
      live_range_end = monoeg_malloc0 (D.53322);
      D.53303 = cfg->next_vreg;
      D.53304 = (long unsigned int) D.53303;
      D.53322 = D.53304 * 8;
      live_range_start_bb = monoeg_malloc (D.53322);
      D.53303 = cfg->next_vreg;
      D.53304 = (long unsigned int) D.53303;
      D.53322 = D.53304 * 8;
      live_range_end_bb = monoeg_malloc (D.53322);
      bb = cfg->bb_entry;
      goto <D.29022>;
      <D.29021>:
      {
        struct MonoInst * ins;

        D.53323 = cfg->verbose_level;
        if (D.53323 > 2) goto <D.53324>; else goto <D.53325>;
        <D.53324>:
        D.53326 = bb->block_num;
        printf ("\nSPILL BLOCK %d:\n", D.53326);
        <D.53325>:
        i = 0;
        goto <D.28966>;
        <D.28965>:
        D.53291 = (long unsigned int) i;
        D.53327 = D.53291 * 4;
        D.53328 = lvregs + D.53327;
        D.53329 = *D.53328;
        D.53330 = (long unsigned int) D.53329;
        D.53331 = D.53330 * 4;
        D.53332 = vreg_to_lvreg + D.53331;
        *D.53332 = 0;
        i = i + 1;
        <D.28966>:
        if (i < lvregs_len) goto <D.28965>; else goto <D.28967>;
        <D.28967>:
        lvregs_len = 0;
        cfg->cbb = bb;
        ins = bb->code;
        goto <D.29014>;
        <D.29013>:
        {
          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.53333 = ins->opcode;
              D.53334 = (int) D.53333;
              D.53335 = D.53334 + -313;
              D.53336 = D.53335 * 4;
              spec = &ins_info[D.53336];
              D.53323 = cfg->verbose_level;
              D.53337 = D.53323 > 2;
              D.53338 = (long int) D.53337;
              D.53339 = __builtin_expect (D.53338, 0);
              if (D.53339 != 0) goto <D.53340>; else goto <D.53341>;
              <D.53340>:
              mono_print_ins (ins);
              <D.53341>:
              D.53333 = ins->opcode;
              if (D.53333 == 316) goto <D.53342>; else goto <D.53343>;
              <D.53342>:
              // predicted unlikely by continue predictor.
              goto <D.28978>;
              <D.53343>:
              D.53333 = ins->opcode;
              if (D.53333 == 314) goto <D.53344>; else goto <D.53345>;
              <D.53344>:
              {
                struct MonoInst * var;

                var = ins->data.op[0].p;
                D.53346 = var->opcode;
                if (D.53346 == 368) goto <D.53347>; else goto <D.53348>;
                <D.53347>:
                {
                  struct MonoInst * vtaddr;

                  vtaddr = var->data.op[0].src;
                  D.53349 = vtaddr->opcode;
                  if (D.53349 == 366) goto <D.53350>; else goto <D.53351>;
                  <D.53350>:
                  ins->opcode = 424;
                  D.53352 = vtaddr->dreg;
                  ins->sreg1 = D.53352;
                  goto <D.53353>;
                  <D.53351>:
                  D.53354 = var->data.op[0].src;
                  D.53355 = D.53354->opcode;
                  if (D.53355 == 367) goto <D.53356>; else goto <D.53357>;
                  <D.53356>:
                  ins->opcode = 388;
                  D.53358 = vtaddr->sreg1;
                  ins->sreg1 = D.53358;
                  D.53359 = vtaddr->data.op[0].const_val;
                  ins->data.op[0].const_val = D.53359;
                  goto <D.53360>;
                  <D.53357>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12918);
                  <D.53360>:
                  <D.53353>:
                }
                goto <D.53361>;
                <D.53348>:
                D.53300 = cfg->gsharedvt;
                if (D.53300 != 0) goto <D.53364>; else goto <D.53362>;
                <D.53364>:
                D.53365 = var->dreg;
                D.53366 = (long unsigned int) D.53365;
                D.53367 = D.53366 * 4;
                D.53368 = gsharedvt_vreg_to_idx + D.53367;
                D.53369 = *D.53368;
                if (D.53369 < 0) goto <D.53370>; else goto <D.53362>;
                <D.53370>:
                D.53346 = var->opcode;
                D.53371 = D.53346 != 332;
                D.53372 = (long int) D.53371;
                D.53373 = __builtin_expect (D.53372, 0);
                if (D.53373 != 0) goto <D.53374>; else goto <D.53375>;
                <D.53374>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12921, "var->opcode == OP_GSHAREDVT_ARG_REGOFFSET");
                <D.53375>:
                ins->opcode = 388;
                D.53376 = var->sreg1;
                ins->sreg1 = D.53376;
                D.53377 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.53377;
                goto <D.53363>;
                <D.53362>:
                D.53300 = cfg->gsharedvt;
                if (D.53300 != 0) goto <D.53380>; else goto <D.53378>;
                <D.53380>:
                D.53365 = var->dreg;
                D.53366 = (long unsigned int) D.53365;
                D.53367 = D.53366 * 4;
                D.53368 = gsharedvt_vreg_to_idx + D.53367;
                D.53369 = *D.53368;
                if (D.53369 != 0) goto <D.53381>; else goto <D.53378>;
                <D.53381>:
                {
                  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.53365 = var->dreg;
                  D.53366 = (long unsigned int) D.53365;
                  D.53367 = D.53366 * 4;
                  D.53368 = gsharedvt_vreg_to_idx + D.53367;
                  D.53369 = *D.53368;
                  idx = D.53369 + -1;
                  info_var = cfg->gsharedvt_info_var;
                  locals_var = cfg->gsharedvt_locals_var;
                  D.53346 = var->opcode;
                  D.53382 = D.53346 != 331;
                  D.53383 = (long int) D.53382;
                  D.53384 = __builtin_expect (D.53383, 0);
                  if (D.53384 != 0) goto <D.53385>; else goto <D.53386>;
                  <D.53385>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12938, "var->opcode == OP_GSHAREDVT_LOCAL");
                  <D.53386>:
                  D.53387 = info_var == 0B;
                  D.53388 = (long int) D.53387;
                  D.53389 = __builtin_expect (D.53388, 0);
                  if (D.53389 != 0) goto <D.53390>; else goto <D.53391>;
                  <D.53390>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12940, "info_var");
                  <D.53391>:
                  D.53392 = locals_var == 0B;
                  D.53393 = (long int) D.53392;
                  D.53394 = __builtin_expect (D.53393, 0);
                  if (D.53394 != 0) goto <D.53395>; else goto <D.53396>;
                  <D.53395>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12941, "locals_var");
                  <D.53396>:
                  cfg->gsharedvt_locals_var_ins = 0B;
                  D.53397 = info_var->opcode;
                  if (D.53397 == 367) goto <D.53398>; else goto <D.53399>;
                  <D.53398>:
                  D.53400 = alloc_ireg (cfg);
                  reg1 = (int) D.53400;
                  D.53320 = cfg->mempool;
                  load = mono_mempool_alloc (D.53320, 80);
                  load->data.op[1].const_val = 0;
                  D.53401 = load->data.op[1].const_val;
                  load->data.op[0].const_val = D.53401;
                  load->prev = 0B;
                  D.53402 = load->prev;
                  load->next = D.53402;
                  load->opcode = 388;
                  load->flags = 0;
                  load->type = 0;
                  load->dreg = -1;
                  load->sreg3 = -1;
                  D.53403 = load->sreg3;
                  load->sreg2 = D.53403;
                  D.53404 = load->sreg2;
                  load->sreg1 = D.53404;
                  D.53405 = cfg->ip;
                  load->cil_code = D.53405;
                  load->dreg = reg1;
                  D.53406 = info_var->sreg1;
                  load->sreg1 = D.53406;
                  D.53407 = info_var->data.op[0].const_val;
                  load->data.op[0].const_val = D.53407;
                  load->type = 1;
                  goto <D.53408>;
                  <D.53399>:
                  D.53397 = info_var->opcode;
                  if (D.53397 == 366) goto <D.53409>; else goto <D.53410>;
                  <D.53409>:
                  load = 0B;
                  reg1 = info_var->dreg;
                  goto <D.53411>;
                  <D.53410>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12954);
                  <D.53411>:
                  <D.53408>:
                  D.53412 = alloc_ireg (cfg);
                  reg2 = (int) D.53412;
                  D.53320 = cfg->mempool;
                  load2 = mono_mempool_alloc (D.53320, 80);
                  load2->data.op[1].const_val = 0;
                  D.53413 = load2->data.op[1].const_val;
                  load2->data.op[0].const_val = D.53413;
                  load2->prev = 0B;
                  D.53414 = load2->prev;
                  load2->next = D.53414;
                  load2->opcode = 393;
                  load2->flags = 0;
                  load2->type = 0;
                  load2->dreg = -1;
                  load2->sreg3 = -1;
                  D.53415 = load2->sreg3;
                  load2->sreg2 = D.53415;
                  D.53416 = load2->sreg2;
                  load2->sreg1 = D.53416;
                  D.53405 = cfg->ip;
                  load2->cil_code = D.53405;
                  load2->dreg = reg2;
                  load2->sreg1 = reg1;
                  D.53417 = (long unsigned int) idx;
                  D.53418 = D.53417 + 1;
                  D.53419 = D.53418 * 8;
                  D.53420 = (long int) D.53419;
                  load2->data.op[0].const_val = D.53420;
                  load2->type = 1;
                  D.53421 = alloc_ireg (cfg);
                  reg3 = (int) D.53421;
                  D.53422 = locals_var->opcode;
                  if (D.53422 == 367) goto <D.53423>; else goto <D.53424>;
                  <D.53423>:
                  D.53320 = cfg->mempool;
                  load3 = mono_mempool_alloc (D.53320, 80);
                  load3->data.op[1].const_val = 0;
                  D.53425 = load3->data.op[1].const_val;
                  load3->data.op[0].const_val = D.53425;
                  load3->prev = 0B;
                  D.53426 = load3->prev;
                  load3->next = D.53426;
                  load3->opcode = 388;
                  load3->flags = 0;
                  load3->type = 0;
                  load3->dreg = -1;
                  load3->sreg3 = -1;
                  D.53427 = load3->sreg3;
                  load3->sreg2 = D.53427;
                  D.53428 = load3->sreg2;
                  load3->sreg1 = D.53428;
                  D.53405 = cfg->ip;
                  load3->cil_code = D.53405;
                  load3->dreg = reg3;
                  D.53429 = locals_var->sreg1;
                  load3->sreg1 = D.53429;
                  D.53430 = locals_var->data.op[0].const_val;
                  load3->data.op[0].const_val = D.53430;
                  load3->type = 1;
                  goto <D.53431>;
                  <D.53424>:
                  D.53422 = locals_var->opcode;
                  if (D.53422 == 366) goto <D.53432>; else goto <D.53433>;
                  <D.53432>:
                  D.53320 = cfg->mempool;
                  load3 = mono_mempool_alloc (D.53320, 80);
                  load3->data.op[1].const_val = 0;
                  D.53425 = load3->data.op[1].const_val;
                  load3->data.op[0].const_val = D.53425;
                  load3->prev = 0B;
                  D.53426 = load3->prev;
                  load3->next = D.53426;
                  load3->opcode = 424;
                  load3->flags = 0;
                  load3->type = 0;
                  load3->dreg = -1;
                  load3->sreg3 = -1;
                  D.53427 = load3->sreg3;
                  load3->sreg2 = D.53427;
                  D.53428 = load3->sreg2;
                  load3->sreg1 = D.53428;
                  D.53405 = cfg->ip;
                  load3->cil_code = D.53405;
                  load3->dreg = reg3;
                  D.53434 = locals_var->dreg;
                  load3->sreg1 = D.53434;
                  goto <D.53435>;
                  <D.53433>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12965);
                  <D.53435>:
                  <D.53431>:
                  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.53436>; else goto <D.53437>;
                  <D.53436>:
                  mono_bblock_insert_before_ins (bb, load2, load);
                  <D.53437>:
                }
                goto <D.53379>;
                <D.53378>:
                D.53346 = var->opcode;
                D.53438 = D.53346 != 367;
                D.53439 = (long int) D.53438;
                D.53440 = __builtin_expect (D.53439, 0);
                if (D.53440 != 0) goto <D.53441>; else goto <D.53442>;
                <D.53441>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12977, "var->opcode == OP_REGOFFSET");
                <D.53442>:
                ins->opcode = 429;
                D.53376 = var->sreg1;
                ins->sreg1 = D.53376;
                D.53377 = var->data.op[0].const_val;
                ins->data.op[1].const_val = D.53377;
                <D.53379>:
                <D.53363>:
                <D.53361>:
                *need_local_opts = 1;
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53335 = D.53334 + -313;
                D.53336 = D.53335 * 4;
                spec = &ins_info[D.53336];
              }
              <D.53345>:
              D.53333 = ins->opcode;
              if (D.53333 <= 312) goto <D.53443>; else goto <D.53444>;
              <D.53443>:
              mono_print_ins (ins);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12990);
              <D.53444>:
              D.53333 = ins->opcode;
              D.53445 = D.53333 + 65162;
              if (D.53445 <= 13) goto <D.53446>; else goto <D.53447>;
              <D.53446>:
              tmp_reg = ins->dreg;
              D.53448 = ins->sreg2;
              ins->dreg = D.53448;
              ins->sreg2 = tmp_reg;
              store = 1;
              spec2[0] = 32;
              D.53449 = MEM[(const char *)spec + 1B];
              spec2[1] = D.53449;
              D.53450 = *spec;
              spec2[2] = D.53450;
              spec2[3] = 32;
              spec = &spec2;
              goto <D.53451>;
              <D.53447>:
              D.53333 = ins->opcode;
              D.53452 = D.53333 + 65126;
              if (D.53452 <= 6) goto <D.53453>; else goto <D.53454>;
              <D.53453>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 13010);
              <D.53454>:
              store = 0;
              <D.53451>:
              no_lvreg = 0;
              D.53323 = cfg->verbose_level;
              D.53337 = D.53323 > 2;
              D.53338 = (long int) D.53337;
              D.53339 = __builtin_expect (D.53338, 0);
              if (D.53339 != 0) goto <D.53455>; else goto <D.53456>;
              <D.53455>:
              D.53457 = ins->dreg;
              printf ("\t %.3s %d", spec, D.53457);
              D.53458 = ins->sreg1;
              sregs[0] = D.53458;
              D.53448 = ins->sreg2;
              sregs[1] = D.53448;
              D.53459 = ins->sreg3;
              sregs[2] = D.53459;
              D.53333 = ins->opcode;
              D.53334 = (int) D.53333;
              D.53335 = D.53334 + -313;
              D.53460 = ins_sreg_counts[D.53335];
              num_sregs = (int) D.53460;
              srcindex = 0;
              goto <D.28991>;
              <D.28990>:
              D.53461 = sregs[srcindex];
              printf (" %d", D.53461);
              srcindex = srcindex + 1;
              <D.28991>:
              if (srcindex < num_sregs) goto <D.28990>; else goto <D.28992>;
              <D.28992>:
              printf ("\n");
              <D.53456>:
              D.53450 = *spec;
              regtype = (int) D.53450;
              D.53457 = ins->dreg;
              if (D.53457 != -1) goto <D.53463>; else goto <D.53467>;
              <D.53467>:
              if (regtype != 32) goto <D.53463>; else goto <D.53464>;
              <D.53463>:
              D.53457 = ins->dreg;
              if (D.53457 == -1) goto <D.53465>; else goto <D.53468>;
              <D.53468>:
              if (regtype == 32) goto <D.53465>; else goto <D.53464>;
              <D.53465>:
              iftmp.513 = 1;
              goto <D.53466>;
              <D.53464>:
              iftmp.513 = 0;
              <D.53466>:
              D.53469 = iftmp.513 != 0;
              D.53470 = (long int) D.53469;
              D.53471 = __builtin_expect (D.53470, 0);
              if (D.53471 != 0) goto <D.53472>; else goto <D.53473>;
              <D.53472>:
              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.53473>:
              prev_dreg = -1;
              D.53457 = ins->dreg;
              if (D.53457 != -1) goto <D.53474>; else goto <D.53475>;
              <D.53474>:
              D.53457 = ins->dreg;
              D.53476 = (unsigned int) D.53457;
              D.53477 = cfg->vreg_to_inst_len;
              if (D.53476 < D.53477) goto <D.53478>; else goto <D.53479>;
              <D.53478>:
              D.53480 = cfg->vreg_to_inst;
              D.53457 = ins->dreg;
              D.53481 = (long unsigned int) D.53457;
              D.53482 = D.53481 * 8;
              D.53483 = D.53480 + D.53482;
              D.53484 = *D.53483;
              if (D.53484 != 0B) goto <D.53485>; else goto <D.53486>;
              <D.53485>:
              {
                struct MonoInst * var;
                struct MonoInst * store_ins;
                int store_opcode;
                struct MonoInst * def_ins;
                int dreg;

                D.53457 = ins->dreg;
                D.53476 = (unsigned int) D.53457;
                D.53477 = cfg->vreg_to_inst_len;
                if (D.53476 < D.53477) goto <D.53488>; else goto <D.53489>;
                <D.53488>:
                D.53480 = cfg->vreg_to_inst;
                D.53457 = ins->dreg;
                D.53481 = (long unsigned int) D.53457;
                D.53482 = D.53481 * 8;
                D.53483 = D.53480 + D.53482;
                iftmp.514 = *D.53483;
                goto <D.53490>;
                <D.53489>:
                iftmp.514 = 0B;
                <D.53490>:
                var = iftmp.514;
                def_ins = ins;
                dreg = ins->dreg;
                D.53491 = var->data.op[1].vtype;
                D.53492 = mono_type_to_store_membase (cfg, D.53491);
                store_opcode = (int) D.53492;
                D.53493 = var->opcode;
                if (D.53493 == 366) goto <D.53494>; else goto <D.53495>;
                <D.53494>:
                D.53496 = var->dreg;
                ins->dreg = D.53496;
                goto <D.53497>;
                <D.53495>:
                D.53457 = ins->dreg;
                D.53458 = ins->sreg1;
                if (D.53457 == D.53458) goto <D.53500>; else goto <D.53498>;
                <D.53500>:
                D.53450 = *spec;
                if (D.53450 == 105) goto <D.53501>; else goto <D.53498>;
                <D.53501>:
                D.53502 = spec + 1;
                D.53503 = *D.53502;
                if (D.53503 == 105) goto <D.53504>; else goto <D.53498>;
                <D.53504>:
                D.53457 = ins->dreg;
                D.53481 = (long unsigned int) D.53457;
                D.53505 = D.53481 * 4;
                D.53506 = vreg_to_lvreg + D.53505;
                D.53507 = *D.53506;
                if (D.53507 == 0) goto <D.53508>; else goto <D.53498>;
                <D.53508>:
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53509 = op_to_op_dest_membase (store_opcode, D.53334);
                if (D.53509 != -1) goto <D.53510>; else goto <D.53498>;
                <D.53510>:
                D.53493 = var->opcode;
                D.53511 = D.53493 != 367;
                D.53512 = (long int) D.53511;
                D.53513 = __builtin_expect (D.53512, 0);
                if (D.53513 != 0) goto <D.53514>; else goto <D.53515>;
                <D.53514>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13045, "var->opcode == OP_REGOFFSET");
                <D.53515>:
                D.53333 = ins->opcode;
                if (D.53333 == 424) goto <D.53516>; else goto <D.53517>;
                <D.53516>:
                ins->opcode = 316;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.53459 = ins->sreg3;
                ins->sreg2 = D.53459;
                D.53448 = ins->sreg2;
                ins->sreg1 = D.53448;
                def_ins = 0B;
                goto <D.53518>;
                <D.53517>:
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53519 = op_to_op_dest_membase (store_opcode, D.53334);
                D.53520 = (short unsigned int) D.53519;
                ins->opcode = D.53520;
                D.53521 = var->sreg1;
                ins->sreg1 = D.53521;
                D.53522 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.53522;
                ins->dreg = -1;
                <D.53518>:
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53335 = D.53334 + -313;
                D.53336 = D.53335 * 4;
                spec = &ins_info[D.53336];
                goto <D.53499>;
                <D.53498>:
                {
                  guint32 lvreg;

                  D.53493 = var->opcode;
                  D.53511 = D.53493 != 367;
                  D.53512 = (long int) D.53511;
                  D.53513 = __builtin_expect (D.53512, 0);
                  if (D.53513 != 0) goto <D.53523>; else goto <D.53524>;
                  <D.53523>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13059, "var->opcode == OP_REGOFFSET");
                  <D.53524>:
                  prev_dreg = ins->dreg;
                  D.53457 = ins->dreg;
                  D.53481 = (long unsigned int) D.53457;
                  D.53505 = D.53481 * 4;
                  D.53506 = vreg_to_lvreg + D.53505;
                  *D.53506 = 0;
                  lvreg = 0;
                  if (0 != 0) goto <D.53525>; else goto <D.53526>;
                  <D.53525>:
                  regtype = 108;
                  store_opcode = 378;
                  <D.53526>:
                  D.53527 = stacktypes[regtype];
                  D.53528 = alloc_dreg (cfg, D.53527);
                  D.53529 = (int) D.53528;
                  ins->dreg = D.53529;
                  D.53530 = store_opcode == 387;
                  D.53531 = (long int) D.53530;
                  D.53532 = __builtin_expect (D.53531, 0);
                  if (D.53532 != 0) goto <D.53533>; else goto <D.53534>;
                  <D.53533>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13086, "store_opcode != OP_STOREV_MEMBASE");
                  <D.53534>:
                  if (lvreg == 0) goto <D.53538>; else goto <D.53535>;
                  <D.53538>:
                  D.53333 = ins->opcode;
                  if (D.53333 == 362) goto <D.53536>; else goto <D.53539>;
                  <D.53539>:
                  D.53333 = ins->opcode;
                  if (D.53333 == 363) goto <D.53540>; else goto <D.53535>;
                  <D.53540>:
                  D.53541 = ins->data.op[0].const_val;
                  if (D.53541 == 0) goto <D.53536>; else goto <D.53535>;
                  <D.53536>:
                  D.53542 = store_membase_reg_to_store_membase_imm (store_opcode);
                  D.53543 = (short unsigned int) D.53542;
                  ins->opcode = D.53543;
                  D.53541 = ins->data.op[0].const_val;
                  ins->data.op[1].const_val = D.53541;
                  D.53521 = var->sreg1;
                  ins->dreg = D.53521;
                  D.53522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.53522;
                  D.53333 = ins->opcode;
                  D.53334 = (int) D.53333;
                  D.53335 = D.53334 + -313;
                  D.53336 = D.53335 * 4;
                  spec = &ins_info[D.53336];
                  goto <D.53537>;
                  <D.53535>:
                  if (lvreg == 0) goto <D.53547>; else goto <D.53544>;
                  <D.53547>:
                  D.53333 = ins->opcode;
                  if (D.53333 == 424) goto <D.53545>; else goto <D.53548>;
                  <D.53548>:
                  D.53333 = ins->opcode;
                  if (D.53333 == 426) goto <D.53545>; else goto <D.53549>;
                  <D.53549>:
                  D.53333 = ins->opcode;
                  if (D.53333 == 425) goto <D.53545>; else goto <D.53544>;
                  <D.53545>:
                  D.53550 = (short unsigned int) store_opcode;
                  ins->opcode = D.53550;
                  D.53521 = var->sreg1;
                  ins->dreg = D.53521;
                  D.53522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.53522;
                  no_lvreg = 1;
                  tmp_reg = ins->dreg;
                  D.53448 = ins->sreg2;
                  ins->dreg = D.53448;
                  ins->sreg2 = tmp_reg;
                  store = 1;
                  spec2[0] = 32;
                  D.53449 = MEM[(const char *)spec + 1B];
                  spec2[1] = D.53449;
                  D.53450 = *spec;
                  spec2[2] = D.53450;
                  spec2[3] = 32;
                  spec = &spec2;
                  goto <D.53546>;
                  <D.53544>:
                  if (lvreg == 0) goto <D.53553>; else goto <D.53551>;
                  <D.53553>:
                  D.53333 = ins->opcode;
                  D.53334 = (int) D.53333;
                  D.53554 = op_to_op_store_membase (store_opcode, D.53334);
                  if (D.53554 != -1) goto <D.53555>; else goto <D.53551>;
                  <D.53555>:
                  D.53333 = ins->opcode;
                  D.53334 = (int) D.53333;
                  D.53556 = op_to_op_store_membase (store_opcode, D.53334);
                  D.53557 = (short unsigned int) D.53556;
                  ins->opcode = D.53557;
                  ins->dreg = -1;
                  D.53521 = var->sreg1;
                  ins->sreg1 = D.53521;
                  D.53522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.53522;
                  D.53333 = ins->opcode;
                  D.53334 = (int) D.53333;
                  D.53335 = D.53334 + -313;
                  D.53336 = D.53335 * 4;
                  spec = &ins_info[D.53336];
                  goto <D.53552>;
                  <D.53551>:
                  D.53320 = cfg->mempool;
                  store_ins = mono_mempool_alloc (D.53320, 80);
                  store_ins->data.op[1].const_val = 0;
                  D.53558 = store_ins->data.op[1].const_val;
                  store_ins->data.op[0].const_val = D.53558;
                  store_ins->prev = 0B;
                  D.53559 = store_ins->prev;
                  store_ins->next = D.53559;
                  D.53550 = (short unsigned int) store_opcode;
                  store_ins->opcode = D.53550;
                  store_ins->flags = 0;
                  store_ins->type = 0;
                  store_ins->dreg = -1;
                  store_ins->sreg3 = -1;
                  D.53560 = store_ins->sreg3;
                  store_ins->sreg2 = D.53560;
                  D.53561 = store_ins->sreg2;
                  store_ins->sreg1 = D.53561;
                  D.53405 = cfg->ip;
                  store_ins->cil_code = D.53405;
                  D.53457 = ins->dreg;
                  store_ins->sreg1 = D.53457;
                  D.53521 = var->sreg1;
                  store_ins->dreg = D.53521;
                  D.53522 = var->data.op[0].const_val;
                  store_ins->data.op[0].const_val = D.53522;
                  mono_bblock_insert_after_ins (bb, ins, store_ins);
                  def_ins = store_ins;
                  D.53562 = var->flags;
                  D.53563 = (int) D.53562;
                  D.53564 = D.53563 & 20;
                  if (D.53564 == 0) goto <D.53565>; else goto <D.53566>;
                  <D.53565>:
                  dest_has_lvreg = 1;
                  <D.53566>:
                  <D.53552>:
                  <D.53546>:
                  <D.53537>:
                }
                <D.53499>:
                <D.53497>:
                if (def_ins != 0B) goto <D.53567>; else goto <D.53568>;
                <D.53567>:
                D.53569 = (long unsigned int) dreg;
                D.53570 = D.53569 * 8;
                D.53571 = live_range_start + D.53570;
                D.53572 = *D.53571;
                if (D.53572 == 0B) goto <D.53573>; else goto <D.53574>;
                <D.53573>:
                D.53569 = (long unsigned int) dreg;
                D.53570 = D.53569 * 8;
                D.53571 = live_range_start + D.53570;
                *D.53571 = def_ins;
                D.53569 = (long unsigned int) dreg;
                D.53570 = D.53569 * 8;
                D.53575 = live_range_start_bb + D.53570;
                *D.53575 = bb;
                <D.53574>:
                <D.53568>:
                D.53286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.53287 = D.53286 & 128;
                if (D.53287 != 0) goto <D.53576>; else goto <D.53577>;
                <D.53576>:
                if (def_ins != 0B) goto <D.53578>; else goto <D.53579>;
                <D.53578>:
                D.53562 = var->flags;
                D.53580 = (signed char) D.53562;
                if (D.53580 < 0) goto <D.53581>; else goto <D.53582>;
                <D.53581>:
                {
                  struct MonoInst * tmp;

                  D.53320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.53320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.53583 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.53583;
                  tmp->prev = 0B;
                  D.53584 = tmp->prev;
                  tmp->next = D.53584;
                  tmp->opcode = 838;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.53585 = tmp->sreg3;
                  tmp->sreg2 = D.53585;
                  D.53586 = tmp->sreg2;
                  tmp->sreg1 = D.53586;
                  D.53405 = cfg->ip;
                  tmp->cil_code = D.53405;
                  D.53587 = (long int) dreg;
                  tmp->data.op[1].const_val = D.53587;
                  mono_bblock_insert_after_ins (bb, def_ins, tmp);
                }
                <D.53582>:
                <D.53579>:
                <D.53577>:
              }
              <D.53486>:
              <D.53479>:
              <D.53475>:
              D.53458 = ins->sreg1;
              sregs[0] = D.53458;
              D.53448 = ins->sreg2;
              sregs[1] = D.53448;
              D.53459 = ins->sreg3;
              sregs[2] = D.53459;
              D.53333 = ins->opcode;
              D.53334 = (int) D.53333;
              D.53335 = D.53334 + -313;
              D.53460 = ins_sreg_counts[D.53335];
              num_sregs = (int) D.53460;
              srcindex = 0;
              goto <D.29008>;
              <D.29007>:
              D.53588 = srcindex + 1;
              D.53589 = (sizetype) D.53588;
              D.53590 = spec + D.53589;
              D.53591 = *D.53590;
              regtype = (int) D.53591;
              sreg = sregs[srcindex];
              if (sreg != -1) goto <D.53593>; else goto <D.53597>;
              <D.53597>:
              if (regtype != 32) goto <D.53593>; else goto <D.53594>;
              <D.53593>:
              if (sreg == -1) goto <D.53595>; else goto <D.53598>;
              <D.53598>:
              if (regtype == 32) goto <D.53595>; else goto <D.53594>;
              <D.53595>:
              iftmp.515 = 1;
              goto <D.53596>;
              <D.53594>:
              iftmp.515 = 0;
              <D.53596>:
              D.53599 = iftmp.515 != 0;
              D.53600 = (long int) D.53599;
              D.53601 = __builtin_expect (D.53600, 0);
              if (D.53601 != 0) goto <D.53602>; else goto <D.53603>;
              <D.53602>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13163, "((sreg == -1) && (regtype == \' \')) || ((sreg != -1) && (regtype != \' \'))");
              <D.53603>:
              if (sreg != -1) goto <D.53604>; else goto <D.53605>;
              <D.53604>:
              sreg.516 = (unsigned int) sreg;
              D.53477 = cfg->vreg_to_inst_len;
              if (sreg.516 < D.53477) goto <D.53607>; else goto <D.53608>;
              <D.53607>:
              D.53480 = cfg->vreg_to_inst;
              D.53609 = (long unsigned int) sreg;
              D.53610 = D.53609 * 8;
              D.53611 = D.53480 + D.53610;
              D.53612 = *D.53611;
              if (D.53612 != 0B) goto <D.53613>; else goto <D.53614>;
              <D.53613>:
              {
                struct MonoInst * var;
                struct MonoInst * use_ins;
                struct MonoInst * load_ins;
                guint32 load_opcode;

                sreg.516 = (unsigned int) sreg;
                D.53477 = cfg->vreg_to_inst_len;
                if (sreg.516 < D.53477) goto <D.53616>; else goto <D.53617>;
                <D.53616>:
                D.53480 = cfg->vreg_to_inst;
                D.53609 = (long unsigned int) sreg;
                D.53610 = D.53609 * 8;
                D.53611 = D.53480 + D.53610;
                iftmp.517 = *D.53611;
                goto <D.53618>;
                <D.53617>:
                iftmp.517 = 0B;
                <D.53618>:
                var = iftmp.517;
                use_ins = ins;
                D.53619 = var->opcode;
                if (D.53619 == 366) goto <D.53620>; else goto <D.53621>;
                <D.53620>:
                D.53622 = var->dreg;
                sregs[srcindex] = D.53622;
                D.53609 = (long unsigned int) sreg;
                D.53610 = D.53609 * 8;
                D.53623 = live_range_end + D.53610;
                *D.53623 = use_ins;
                D.53609 = (long unsigned int) sreg;
                D.53610 = D.53609 * 8;
                D.53624 = live_range_end_bb + D.53610;
                *D.53624 = bb;
                D.53286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.53287 = D.53286 & 128;
                if (D.53287 != 0) goto <D.53625>; else goto <D.53626>;
                <D.53625>:
                D.53622 = var->dreg;
                if (D.53622 < orig_next_vreg) goto <D.53627>; else goto <D.53628>;
                <D.53627>:
                D.53629 = var->flags;
                D.53630 = (signed char) D.53629;
                if (D.53630 < 0) goto <D.53631>; else goto <D.53632>;
                <D.53631>:
                {
                  struct MonoInst * tmp;

                  D.53320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.53320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.53633 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.53633;
                  tmp->prev = 0B;
                  D.53634 = tmp->prev;
                  tmp->next = D.53634;
                  tmp->opcode = 839;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.53635 = tmp->sreg3;
                  tmp->sreg2 = D.53635;
                  D.53636 = tmp->sreg2;
                  tmp->sreg1 = D.53636;
                  D.53405 = cfg->ip;
                  tmp->cil_code = D.53405;
                  D.53637 = (long int) sreg;
                  tmp->data.op[1].const_val = D.53637;
                  mono_bblock_insert_after_ins (bb, ins, tmp);
                }
                <D.53632>:
                <D.53628>:
                <D.53626>:
                // predicted unlikely by continue predictor.
                goto <D.29005>;
                <D.53621>:
                D.53619 = var->opcode;
                D.53638 = D.53619 != 367;
                D.53639 = (long int) D.53638;
                D.53640 = __builtin_expect (D.53639, 0);
                if (D.53640 != 0) goto <D.53641>; else goto <D.53642>;
                <D.53641>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13188, "var->opcode == OP_REGOFFSET");
                <D.53642>:
                D.53643 = var->data.op[1].vtype;
                load_opcode = mono_type_to_load_membase (cfg, D.53643);
                D.53644 = load_opcode == 399;
                D.53645 = (long int) D.53644;
                D.53646 = __builtin_expect (D.53645, 0);
                if (D.53646 != 0) goto <D.53647>; else goto <D.53648>;
                <D.53647>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13192, "load_opcode != OP_LOADV_MEMBASE");
                <D.53648>:
                D.53609 = (long unsigned int) sreg;
                D.53649 = D.53609 * 4;
                D.53650 = vreg_to_lvreg + D.53649;
                D.53651 = *D.53650;
                if (D.53651 != 0) goto <D.53652>; else goto <D.53653>;
                <D.53652>:
                D.53609 = (long unsigned int) sreg;
                D.53649 = D.53609 * 4;
                D.53650 = vreg_to_lvreg + D.53649;
                D.53651 = *D.53650;
                D.53654 = D.53651 == 4294967295;
                D.53655 = (long int) D.53654;
                D.53656 = __builtin_expect (D.53655, 0);
                if (D.53656 != 0) goto <D.53657>; else goto <D.53658>;
                <D.53657>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13195, "vreg_to_lvreg [sreg] != -1");
                <D.53658>:
                D.53323 = cfg->verbose_level;
                D.53337 = D.53323 > 2;
                D.53338 = (long int) D.53337;
                D.53339 = __builtin_expect (D.53338, 0);
                if (D.53339 != 0) goto <D.53659>; else goto <D.53660>;
                <D.53659>:
                D.53609 = (long unsigned int) sreg;
                D.53649 = D.53609 * 4;
                D.53650 = vreg_to_lvreg + D.53649;
                D.53651 = *D.53650;
                printf ("\t\tUse lvreg R%d for R%d.\n", D.53651, sreg);
                <D.53660>:
                D.53609 = (long unsigned int) sreg;
                D.53649 = D.53609 * 4;
                D.53650 = vreg_to_lvreg + D.53649;
                D.53651 = *D.53650;
                D.53661 = (int) D.53651;
                sregs[srcindex] = D.53661;
                // predicted unlikely by continue predictor.
                goto <D.29005>;
                <D.53653>:
                if (srcindex == 0) goto <D.53664>; else goto <D.53662>;
                <D.53664>:
                load_opcode.518 = (int) load_opcode;
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53666 = op_to_op_src1_membase (load_opcode.518, D.53334);
                if (D.53666 != -1) goto <D.53667>; else goto <D.53662>;
                <D.53667>:
                load_opcode.518 = (int) load_opcode;
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53668 = op_to_op_src1_membase (load_opcode.518, D.53334);
                D.53669 = (short unsigned int) D.53668;
                ins->opcode = D.53669;
                D.53670 = var->sreg1;
                sregs[0] = D.53670;
                D.53671 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.53671;
                goto <D.53663>;
                <D.53662>:
                if (srcindex == 1) goto <D.53674>; else goto <D.53672>;
                <D.53674>:
                load_opcode.518 = (int) load_opcode;
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53675 = op_to_op_src2_membase (load_opcode.518, D.53334);
                if (D.53675 != -1) goto <D.53676>; else goto <D.53672>;
                <D.53676>:
                load_opcode.518 = (int) load_opcode;
                D.53333 = ins->opcode;
                D.53334 = (int) D.53333;
                D.53677 = op_to_op_src2_membase (load_opcode.518, D.53334);
                D.53678 = (short unsigned int) D.53677;
                ins->opcode = D.53678;
                D.53670 = var->sreg1;
                sregs[1] = D.53670;
                D.53671 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.53671;
                goto <D.53673>;
                <D.53672>:
                D.53333 = ins->opcode;
                if (D.53333 == 424) goto <D.53679>; else goto <D.53682>;
                <D.53682>:
                D.53333 = ins->opcode;
                if (D.53333 == 426) goto <D.53679>; else goto <D.53680>;
                <D.53679>:
                ins->opcode = 316;
                sreg = ins->dreg;
                goto <D.53681>;
                <D.53680>:
                D.53527 = stacktypes[regtype];
                D.53683 = alloc_dreg (cfg, D.53527);
                sreg = (int) D.53683;
                D.53629 = var->flags;
                D.53684 = (int) D.53629;
                D.53685 = D.53684 & 20;
                D.53686 = D.53685 | no_lvreg;
                if (D.53686 == 0) goto <D.53687>; else goto <D.53688>;
                <D.53687>:
                D.53622 = var->dreg;
                if (D.53622 == prev_dreg) goto <D.53689>; else goto <D.53690>;
                <D.53689>:
                sreg = ins->dreg;
                <D.53690>:
                D.53691 = sreg == -1;
                D.53692 = (long int) D.53691;
                D.53693 = __builtin_expect (D.53692, 0);
                if (D.53693 != 0) goto <D.53694>; else goto <D.53695>;
                <D.53694>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13234, "sreg != -1");
                <D.53695>:
                D.53622 = var->dreg;
                D.53696 = (long unsigned int) D.53622;
                D.53697 = D.53696 * 4;
                D.53698 = vreg_to_lvreg + D.53697;
                sreg.516 = (unsigned int) sreg;
                *D.53698 = sreg.516;
                D.53699 = lvregs_len > 1023;
                D.53700 = (long int) D.53699;
                D.53701 = __builtin_expect (D.53700, 0);
                if (D.53701 != 0) goto <D.53702>; else goto <D.53703>;
                <D.53702>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13236, "lvregs_len < 1024");
                <D.53703>:
                lvregs_len.519 = lvregs_len;
                lvregs_len = lvregs_len.519 + 1;
                D.53705 = (long unsigned int) lvregs_len.519;
                D.53706 = D.53705 * 4;
                D.53707 = lvregs + D.53706;
                D.53622 = var->dreg;
                D.53708 = (unsigned int) D.53622;
                *D.53707 = D.53708;
                <D.53688>:
                <D.53681>:
                sregs[srcindex] = sreg;
                D.53320 = cfg->mempool;
                load_ins = mono_mempool_alloc (D.53320, 80);
                load_ins->data.op[1].const_val = 0;
                D.53709 = load_ins->data.op[1].const_val;
                load_ins->data.op[0].const_val = D.53709;
                load_ins->prev = 0B;
                D.53710 = load_ins->prev;
                load_ins->next = D.53710;
                D.53711 = (short unsigned int) load_opcode;
                load_ins->opcode = D.53711;
                load_ins->flags = 0;
                load_ins->type = 0;
                load_ins->dreg = -1;
                load_ins->sreg3 = -1;
                D.53712 = load_ins->sreg3;
                load_ins->sreg2 = D.53712;
                D.53713 = load_ins->sreg2;
                load_ins->sreg1 = D.53713;
                D.53405 = cfg->ip;
                load_ins->cil_code = D.53405;
                load_ins->dreg = sreg;
                D.53670 = var->sreg1;
                load_ins->sreg1 = D.53670;
                D.53671 = var->data.op[0].const_val;
                load_ins->data.op[0].const_val = D.53671;
                load_ins->type = 1;
                mono_bblock_insert_before_ins (bb, ins, load_ins);
                use_ins = load_ins;
                <D.53673>:
                <D.53663>:
                D.53622 = var->dreg;
                if (D.53622 < orig_next_vreg) goto <D.53714>; else goto <D.53715>;
                <D.53714>:
                D.53622 = var->dreg;
                D.53696 = (long unsigned int) D.53622;
                D.53716 = D.53696 * 8;
                D.53717 = live_range_end + D.53716;
                *D.53717 = use_ins;
                D.53622 = var->dreg;
                D.53696 = (long unsigned int) D.53622;
                D.53716 = D.53696 * 8;
                D.53718 = live_range_end_bb + D.53716;
                *D.53718 = bb;
                <D.53715>:
                D.53286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.53287 = D.53286 & 128;
                if (D.53287 != 0) goto <D.53719>; else goto <D.53720>;
                <D.53719>:
                D.53622 = var->dreg;
                if (D.53622 < orig_next_vreg) goto <D.53721>; else goto <D.53722>;
                <D.53721>:
                D.53629 = var->flags;
                D.53630 = (signed char) D.53629;
                if (D.53630 < 0) goto <D.53723>; else goto <D.53724>;
                <D.53723>:
                {
                  struct MonoInst * tmp;

                  D.53320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.53320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.53725 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.53725;
                  tmp->prev = 0B;
                  D.53726 = tmp->prev;
                  tmp->next = D.53726;
                  tmp->opcode = 839;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.53727 = tmp->sreg3;
                  tmp->sreg2 = D.53727;
                  D.53728 = tmp->sreg2;
                  tmp->sreg1 = D.53728;
                  D.53405 = cfg->ip;
                  tmp->cil_code = D.53405;
                  D.53622 = var->dreg;
                  D.53729 = (long int) D.53622;
                  tmp->data.op[1].const_val = D.53729;
                  mono_bblock_insert_after_ins (bb, ins, tmp);
                }
                <D.53724>:
                <D.53722>:
                <D.53720>:
              }
              <D.53614>:
              <D.53608>:
              <D.53605>:
              <D.29005>:
              srcindex = srcindex + 1;
              <D.29008>:
              if (srcindex <= 2) goto <D.29007>; else goto <D.29009>;
              <D.29009>:
              mono_inst_set_src_registers (ins, &sregs);
              if (dest_has_lvreg != 0) goto <D.53730>; else goto <D.53731>;
              <D.53730>:
              D.53457 = ins->dreg;
              D.53732 = D.53457 == -1;
              D.53733 = (long int) D.53732;
              D.53734 = __builtin_expect (D.53733, 0);
              if (D.53734 != 0) goto <D.53735>; else goto <D.53736>;
              <D.53735>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13281, "ins->dreg != -1");
              <D.53736>:
              D.53737 = (long unsigned int) prev_dreg;
              D.53738 = D.53737 * 4;
              D.53739 = vreg_to_lvreg + D.53738;
              D.53457 = ins->dreg;
              D.53476 = (unsigned int) D.53457;
              *D.53739 = D.53476;
              D.53699 = lvregs_len > 1023;
              D.53700 = (long int) D.53699;
              D.53701 = __builtin_expect (D.53700, 0);
              if (D.53701 != 0) goto <D.53740>; else goto <D.53741>;
              <D.53740>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13283, "lvregs_len < 1024");
              <D.53741>:
              lvregs_len.520 = lvregs_len;
              lvregs_len = lvregs_len.520 + 1;
              D.53743 = (long unsigned int) lvregs_len.520;
              D.53744 = D.53743 * 4;
              D.53745 = lvregs + D.53744;
              prev_dreg.521 = (unsigned int) prev_dreg;
              *D.53745 = prev_dreg.521;
              dest_has_lvreg = 0;
              <D.53731>:
              if (store != 0) goto <D.53747>; else goto <D.53748>;
              <D.53747>:
              tmp_reg = ins->dreg;
              D.53448 = ins->sreg2;
              ins->dreg = D.53448;
              ins->sreg2 = tmp_reg;
              <D.53748>:
              D.53333 = ins->opcode;
              D.53752 = D.53333 + 65193;
              if (D.53752 <= 2) goto <D.53749>; else goto <D.53753>;
              <D.53753>:
              D.53333 = ins->opcode;
              D.53754 = D.53333 + 65187;
              if (D.53754 <= 2) goto <D.53749>; else goto <D.53755>;
              <D.53755>:
              D.53333 = ins->opcode;
              D.53756 = D.53333 + 65184;
              if (D.53756 <= 2) goto <D.53749>; else goto <D.53757>;
              <D.53757>:
              D.53333 = ins->opcode;
              D.53758 = D.53333 + 65181;
              if (D.53758 <= 2) goto <D.53749>; else goto <D.53759>;
              <D.53759>:
              D.53333 = ins->opcode;
              D.53760 = D.53333 + 65190;
              if (D.53760 <= 2) goto <D.53749>; else goto <D.53761>;
              <D.53761>:
              D.53333 = ins->opcode;
              D.53762 = D.53333 + 65178;
              if (D.53762 <= 2) goto <D.53749>; else goto <D.53763>;
              <D.53763>:
              D.53333 = ins->opcode;
              if (D.53333 == 444) goto <D.53749>; else goto <D.53750>;
              <D.53749>:
              i = 0;
              goto <D.29011>;
              <D.29010>:
              D.53291 = (long unsigned int) i;
              D.53327 = D.53291 * 4;
              D.53328 = lvregs + D.53327;
              D.53329 = *D.53328;
              D.53330 = (long unsigned int) D.53329;
              D.53331 = D.53330 * 4;
              D.53332 = vreg_to_lvreg + D.53331;
              *D.53332 = 0;
              i = i + 1;
              <D.29011>:
              if (i < lvregs_len) goto <D.29010>; else goto <D.29012>;
              <D.29012>:
              lvregs_len = 0;
              goto <D.53751>;
              <D.53750>:
              D.53333 = ins->opcode;
              if (D.53333 == 316) goto <D.53764>; else goto <D.53765>;
              <D.53764>:
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.53459 = ins->sreg3;
              ins->sreg2 = D.53459;
              D.53448 = ins->sreg2;
              ins->sreg1 = D.53448;
              <D.53765>:
              <D.53751>:
              D.53323 = cfg->verbose_level;
              if (D.53323 > 2) goto <D.53766>; else goto <D.53767>;
              <D.53766>:
              mono_print_ins_index (1, ins);
              <D.53767>:
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.28978>:
        ins = ins->next;
        <D.29014>:
        if (ins != 0B) goto <D.29013>; else goto <D.29015>;
        <D.29015>:
        D.53768 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.53769 = D.53768 & 9223372036854775808;
        if (D.53769 != 0) goto <D.53770>; else goto <D.53771>;
        <D.53770>:
        D.53772 = bb->live_out_set;
        if (D.53772 != 0B) goto <D.53773>; else goto <D.53774>;
        <D.53773>:
        D.53775 = bb->code;
        if (D.53775 != 0B) goto <D.53776>; else goto <D.53777>;
        <D.53776>:
        i = 0;
        goto <D.29019>;
        <D.29018>:
        {
          struct MonoMethodVar * vi;

          D.53778 = cfg->vars;
          D.53291 = (long unsigned int) i;
          D.53779 = D.53291 * 80;
          vi = D.53778 + D.53779;
          D.53783 = vi->vreg;
          D.53784 = (unsigned int) D.53783;
          D.53477 = cfg->vreg_to_inst_len;
          if (D.53784 < D.53477) goto <D.53785>; else goto <D.53781>;
          <D.53785>:
          D.53480 = cfg->vreg_to_inst;
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53788 = D.53480 + D.53787;
          D.53789 = *D.53788;
          if (D.53789 != 0B) goto <D.53790>; else goto <D.53781>;
          <D.53790>:
          D.53783 = vi->vreg;
          D.53784 = (unsigned int) D.53783;
          D.53477 = cfg->vreg_to_inst_len;
          if (D.53784 < D.53477) goto <D.53792>; else goto <D.53793>;
          <D.53792>:
          D.53480 = cfg->vreg_to_inst;
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53788 = D.53480 + D.53787;
          iftmp.523 = *D.53788;
          goto <D.53794>;
          <D.53793>:
          iftmp.523 = 0B;
          <D.53794>:
          D.53795 = iftmp.523->flags;
          D.53796 = (int) D.53795;
          D.53797 = D.53796 & 20;
          if (D.53797 != 0) goto <D.53798>; else goto <D.53781>;
          <D.53798>:
          iftmp.522 = 1;
          goto <D.53782>;
          <D.53781>:
          iftmp.522 = 0;
          <D.53782>:
          D.53799 = iftmp.522 != 0;
          D.53800 = (long int) D.53799;
          D.53801 = __builtin_expect (D.53800, 0);
          if (D.53801 != 0) goto <D.53802>; else goto <D.53803>;
          <D.53802>:
          // predicted unlikely by continue predictor.
          goto <D.29017>;
          <D.53803>:
          D.53804 = bb->live_in_set;
          D.53805 = i / 64;
          D.53806 = (long unsigned int) D.53805;
          D.53807 = D.53804->data[D.53806];
          i.524 = (int) i;
          D.53809 = i.524 & 63;
          D.53810 = D.53807 >> D.53809;
          D.53811 = D.53810 & 1;
          if (D.53811 != 0) goto <D.53812>; else goto <D.53813>;
          <D.53812>:
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53814 = live_range_start + D.53787;
          D.53815 = *D.53814;
          if (D.53815 == 0B) goto <D.53816>; else goto <D.53817>;
          <D.53816>:
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53814 = live_range_start + D.53787;
          D.53775 = bb->code;
          *D.53814 = D.53775;
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53818 = live_range_start_bb + D.53787;
          *D.53818 = bb;
          <D.53817>:
          <D.53813>:
          D.53772 = bb->live_out_set;
          D.53805 = i / 64;
          D.53806 = (long unsigned int) D.53805;
          D.53819 = D.53772->data[D.53806];
          i.524 = (int) i;
          D.53809 = i.524 & 63;
          D.53820 = D.53819 >> D.53809;
          D.53821 = D.53820 & 1;
          if (D.53821 != 0) goto <D.53822>; else goto <D.53823>;
          <D.53822>:
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53824 = live_range_end + D.53787;
          D.53825 = bb->last_ins;
          *D.53824 = D.53825;
          D.53783 = vi->vreg;
          D.53786 = (long unsigned int) D.53783;
          D.53787 = D.53786 * 8;
          D.53826 = live_range_end_bb + D.53787;
          *D.53826 = bb;
          <D.53823>:
        }
        <D.29017>:
        i = i + 1;
        <D.29019>:
        D.53299 = cfg->num_varinfo;
        if (D.53299 > i) goto <D.29018>; else goto <D.29020>;
        <D.29020>:
        <D.53777>:
        <D.53774>:
        <D.53771>:
      }
      bb = bb->next_bb;
      <D.29022>:
      if (bb != 0B) goto <D.29021>; else goto <D.29023>;
      <D.29023>:
      D.53827 = cfg->gsharedvt_locals_var_ins;
      if (D.53827 != 0B) goto <D.53828>; else goto <D.53829>;
      <D.53828>:
      D.53827 = cfg->gsharedvt_locals_var_ins;
      D.53827->opcode = 363;
      D.53827 = cfg->gsharedvt_locals_var_ins;
      D.53827->data.op[1].const_val = 0;
      <D.53829>:
      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};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.53834;
  int D.53839;
  void * D.53841;
  long unsigned int D.53842;

  D.53834 = __builtin_constant_p (__len);
  if (D.53834 != 0) goto <D.53835>; else goto <D.53836>;
  <D.53835>:
  if (__len == 0) goto <D.53837>; else goto <D.53838>;
  <D.53837>:
  D.53839 = __builtin_constant_p (__ch);
  if (D.53839 == 0) goto <D.53832>; else goto <D.53840>;
  <D.53840>:
  if (__ch != 0) goto <D.53832>; else goto <D.53833>;
  <D.53832>:
  __warn_memset_zero_len ();
  D.53841 = __dest;
  return D.53841;
  <D.53833>:
  <D.53838>:
  <D.53836>:
  D.53842 = __builtin_object_size (__dest, 0);
  D.53841 = __builtin___memset_chk (__dest, __ch, __len, D.53842);
  return D.53841;
}


op_to_op_dest_membase (int store_opcode, int opcode)
{
  int D.53844;

  D.53844 = -1;
  return D.53844;
}


store_membase_reg_to_store_membase_imm (int opcode)
{
  int D.53846;

  switch (opcode) <default: <D.28803>, case 374: <D.28798>, case 375: <D.28799>, case 376: <D.28800>, case 377: <D.28801>, case 378: <D.28802>>
  <D.28798>:
  D.53846 = 381;
  return D.53846;
  <D.28799>:
  D.53846 = 382;
  return D.53846;
  <D.28800>:
  D.53846 = 383;
  return D.53846;
  <D.28801>:
  D.53846 = 384;
  return D.53846;
  <D.28802>:
  D.53846 = 385;
  return D.53846;
  <D.28803>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12041);
  D.53846 = -1;
  return D.53846;
}


op_to_op_store_membase (int store_opcode, int opcode)
{
  int D.53848;

  D.53848 = -1;
  return D.53848;
}


op_to_op_src1_membase (int load_opcode, int opcode)
{
  int D.53850;

  D.53850 = -1;
  return D.53850;
}


op_to_op_src2_membase (int load_opcode, int opcode)
{
  int D.53852;

  D.53852 = -1;
  return D.53852;
}