mono_ldftn (struct MonoMethod * method)
{
  struct MonoDomain * D.23064;
  void * D.23065;
  struct MonoDomain * D.23066;
  void * addr;

  D.23064 = mono_domain_get ();
  addr = mono_create_jump_trampoline (D.23064, method, 0);
  D.23066 = mono_domain_get ();
  D.23065 = mono_create_ftnptr (D.23066, addr);
  return D.23065;
}


mono_ldvirtfn (struct MonoObject * obj, struct MonoMethod * method)
{
  void * D.23068;

  D.23068 = ldvirtfn_internal (obj, method, 0);
  return D.23068;
}


ldvirtfn_internal (struct MonoObject * obj, struct MonoMethod * method, gboolean gshared)
{
  struct MonoException * D.23072;
  unsigned int D.23075;
  unsigned int D.23076;
  struct MonoGenericContext * D.23079;
  struct MonoGenericInst * D.23080;
  struct MonoClass * D.23083;
  struct MonoGenericClass * D.23084;
  struct MonoGenericInst * D.23087;
  struct MonoGenericContainer * D.23089;
  struct MonoGenericInst * D.23092;
  struct MonoGenericContext * D.23093;
  struct MonoGenericInst * D.23094;
  void * D.23095;
  struct MonoMethod * res;

  if (obj == 0B) goto <D.23070>; else goto <D.23071>;
  <D.23070>:
  D.23072 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23072);
  <D.23071>:
  res = mono_object_get_virtual_method (obj, method);
  if (gshared != 0) goto <D.23073>; else goto <D.23074>;
  <D.23073>:
  D.23075 = BIT_FIELD_REF <*method, 32, 160>;
  D.23076 = D.23075 & 4096;
  if (D.23076 != 0) goto <D.23077>; else goto <D.23078>;
  <D.23077>:
  D.23079 = mono_method_get_context (method);
  D.23080 = D.23079->method_inst;
  if (D.23080 != 0B) goto <D.23081>; else goto <D.23082>;
  <D.23081>:
  {
    struct MonoGenericContext context;

    try
      {
        context.class_inst = 0B;
        context.method_inst = 0B;
        D.23083 = res->klass;
        D.23084 = D.23083->generic_class;
        if (D.23084 != 0B) goto <D.23085>; else goto <D.23086>;
        <D.23085>:
        D.23083 = res->klass;
        D.23084 = D.23083->generic_class;
        D.23087 = D.23084->context.class_inst;
        context.class_inst = D.23087;
        goto <D.23088>;
        <D.23086>:
        D.23083 = res->klass;
        D.23089 = D.23083->generic_container;
        if (D.23089 != 0B) goto <D.23090>; else goto <D.23091>;
        <D.23090>:
        D.23083 = res->klass;
        D.23089 = D.23083->generic_container;
        D.23092 = D.23089->context.class_inst;
        context.class_inst = D.23092;
        <D.23091>:
        <D.23088>:
        D.23093 = mono_method_get_context (method);
        D.23094 = D.23093->method_inst;
        context.method_inst = D.23094;
        res = mono_class_inflate_generic_method (res, &context);
      }
    finally
      {
        context = {CLOBBER};
      }
  }
  <D.23082>:
  <D.23078>:
  <D.23074>:
  D.23095 = mono_ldftn (res);
  return D.23095;
}


mono_ldvirtfn_gshared (struct MonoObject * obj, struct MonoMethod * method)
{
  void * D.23097;

  D.23097 = ldvirtfn_internal (obj, method, 1);
  return D.23097;
}


mono_helper_stelem_ref_check (struct MonoArray * array, struct MonoObject * val)
{
  struct MonoException * D.23101;
  struct MonoVTable * D.23104;
  struct MonoClass * D.23105;
  struct MonoClass * D.23106;
  struct MonoObject * D.23107;
  struct MonoException * D.23110;

  if (array == 0B) goto <D.23099>; else goto <D.23100>;
  <D.23099>:
  D.23101 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23101);
  <D.23100>:
  if (val != 0B) goto <D.23102>; else goto <D.23103>;
  <D.23102>:
  D.23104 = array->obj.vtable;
  D.23105 = D.23104->klass;
  D.23106 = D.23105->element_class;
  D.23107 = mono_object_isinst (val, D.23106);
  if (D.23107 == 0B) goto <D.23108>; else goto <D.23109>;
  <D.23108>:
  D.23110 = mono_get_exception_array_type_mismatch ();
  mono_raise_exception (D.23110);
  <D.23109>:
  <D.23103>:
}


mono_llmult (gint64 a, gint64 b)
{
  gint64 D.23111;

  D.23111 = a * b;
  return D.23111;
}


mono_llmult_ovf_un (guint64 a, guint64 b)
{
  long long unsigned int D.23113;
  long long unsigned int D.23114;
  long long unsigned int D.23118;
  long long unsigned int D.23119;
  long long unsigned int D.23120;
  long long unsigned int D.23121;
  long long unsigned int D.23122;
  long long unsigned int D.23123;
  long long unsigned int D.23125;
  guint64 D.23126;
  struct MonoException * D.23127;
  guint32 al;
  guint32 ah;
  guint32 bl;
  guint32 bh;
  guint64 res;
  guint64 t1;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.23113 = a >> 32;
  ah = (guint32) D.23113;
  bl = (guint32) b;
  D.23114 = b >> 32;
  bh = (guint32) D.23114;
  if (ah != 0) goto <D.23115>; else goto <D.23116>;
  <D.23115>:
  if (bh != 0) goto raise_exception; else goto <D.23117>;
  <D.23117>:
  <D.23116>:
  D.23118 = (long long unsigned int) al;
  D.23119 = (long long unsigned int) bl;
  res = D.23118 * D.23119;
  D.23120 = (long long unsigned int) ah;
  D.23119 = (long long unsigned int) bl;
  D.23121 = D.23120 * D.23119;
  D.23118 = (long long unsigned int) al;
  D.23122 = (long long unsigned int) bh;
  D.23123 = D.23118 * D.23122;
  t1 = D.23121 + D.23123;
  if (t1 > 4294967295) goto raise_exception; else goto <D.23124>;
  <D.23124>:
  D.23125 = t1 << 32;
  res = D.23125 + res;
  D.23126 = res;
  return D.23126;
  raise_exception:
  D.23127 = mono_get_exception_overflow ();
  mono_raise_exception (D.23127);
  D.23126 = 0;
  return D.23126;
}


mono_llmult_ovf (gint64 a, gint64 b)
{
  long long int D.23129;
  long long int D.23130;
  guint64 D.23139;
  long long int D.23159;
  long long int D.23160;
  long long int D.23161;
  long long int D.23163;
  long long int D.23164;
  long long int D.23165;
  unsigned int ah.0;
  unsigned int D.23168;
  long long int D.23169;
  unsigned int bh.1;
  unsigned int D.23171;
  long long int D.23172;
  long long int D.23173;
  long long int D.23174;
  long long int D.23179;
  struct MonoException * D.23180;
  guint32 al;
  gint32 ah;
  guint32 bl;
  gint32 bh;
  gint64 res;
  gint64 t1;
  gint32 sign;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.23129 = a >> 32;
  ah = (gint32) D.23129;
  bl = (guint32) b;
  D.23130 = b >> 32;
  bh = (gint32) D.23130;
  sign = ah ^ bh;
  if (ah < 0) goto <D.23131>; else goto <D.23132>;
  <D.23131>:
  if (ah == -2147483648) goto <D.23133>; else goto <D.23134>;
  <D.23133>:
  if (al == 0) goto <D.23135>; else goto <D.23136>;
  <D.23135>:
  if (b == 0) goto <D.23137>; else goto <D.23138>;
  <D.23137>:
  D.23139 = 0;
  return D.23139;
  <D.23138>:
  if (b == 1) goto <D.23140>; else goto raise_exception;
  <D.23140>:
  D.23139 = (guint64) a;
  return D.23139;
  <D.23136>:
  <D.23134>:
  ah = ~ah;
  if (al == 0) goto <D.23141>; else goto <D.23142>;
  <D.23141>:
  ah = ah + 1;
  goto <D.23143>;
  <D.23142>:
  al = ~al;
  al = al + 1;
  <D.23143>:
  <D.23132>:
  if (bh < 0) goto <D.23144>; else goto <D.23145>;
  <D.23144>:
  if (bh == -2147483648) goto <D.23146>; else goto <D.23147>;
  <D.23146>:
  if (bl == 0) goto <D.23148>; else goto <D.23149>;
  <D.23148>:
  if (a == 0) goto <D.23150>; else goto <D.23151>;
  <D.23150>:
  D.23139 = 0;
  return D.23139;
  <D.23151>:
  if (a == 1) goto <D.23152>; else goto raise_exception;
  <D.23152>:
  D.23139 = (guint64) b;
  return D.23139;
  <D.23149>:
  <D.23147>:
  bh = ~bh;
  if (bl == 0) goto <D.23153>; else goto <D.23154>;
  <D.23153>:
  bh = bh + 1;
  goto <D.23155>;
  <D.23154>:
  bl = ~bl;
  bl = bl + 1;
  <D.23155>:
  <D.23145>:
  if (ah != 0) goto <D.23156>; else goto <D.23157>;
  <D.23156>:
  if (bh != 0) goto raise_exception; else goto <D.23158>;
  <D.23158>:
  <D.23157>:
  D.23159 = (long long int) ah;
  D.23160 = (long long int) bl;
  D.23161 = D.23159 * D.23160;
  if (D.23161 > 2147483648) goto raise_exception; else goto <D.23162>;
  <D.23162>:
  D.23163 = (long long int) al;
  D.23164 = (long long int) bh;
  D.23165 = D.23163 * D.23164;
  if (D.23165 > 2147483648) goto raise_exception; else goto <D.23166>;
  <D.23166>:
  D.23163 = (long long int) al;
  D.23160 = (long long int) bl;
  t1 = D.23163 * D.23160;
  res = t1;
  ah.0 = (unsigned int) ah;
  D.23168 = ah.0 - al;
  D.23169 = (long long int) D.23168;
  bh.1 = (unsigned int) bh;
  D.23171 = bl - bh.1;
  D.23172 = (long long int) D.23171;
  D.23173 = D.23169 * D.23172;
  t1 = D.23173 + t1;
  t1 = t1 << 32;
  D.23174 = 9223372036854775807 - res;
  if (D.23174 < t1) goto raise_exception; else goto <D.23175>;
  <D.23175>:
  res = res + t1;
  if (res < 0) goto raise_exception; else goto <D.23176>;
  <D.23176>:
  if (sign < 0) goto <D.23177>; else goto <D.23178>;
  <D.23177>:
  D.23179 = -res;
  D.23139 = (guint64) D.23179;
  return D.23139;
  <D.23178>:
  D.23139 = (guint64) res;
  return D.23139;
  raise_exception:
  D.23180 = mono_get_exception_overflow ();
  mono_raise_exception (D.23180);
  D.23139 = 0;
  return D.23139;
}


mono_lldiv (gint64 a, gint64 b)
{
  struct MonoException * D.23184;
  struct MonoException * D.23190;
  gint64 D.23191;

  if (b == 0) goto <D.23182>; else goto <D.23183>;
  <D.23182>:
  D.23184 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23184);
  goto <D.23185>;
  <D.23183>:
  if (b == -1) goto <D.23186>; else goto <D.23187>;
  <D.23186>:
  if (a == -9223372036854775808) goto <D.23188>; else goto <D.23189>;
  <D.23188>:
  D.23190 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.23190);
  <D.23189>:
  <D.23187>:
  <D.23185>:
  D.23191 = a / b;
  return D.23191;
}


mono_llrem (gint64 a, gint64 b)
{
  struct MonoException * D.23195;
  struct MonoException * D.23201;
  gint64 D.23202;

  if (b == 0) goto <D.23193>; else goto <D.23194>;
  <D.23193>:
  D.23195 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23195);
  goto <D.23196>;
  <D.23194>:
  if (b == -1) goto <D.23197>; else goto <D.23198>;
  <D.23197>:
  if (a == -9223372036854775808) goto <D.23199>; else goto <D.23200>;
  <D.23199>:
  D.23201 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.23201);
  <D.23200>:
  <D.23198>:
  <D.23196>:
  D.23202 = a % b;
  return D.23202;
}


mono_lldiv_un (guint64 a, guint64 b)
{
  struct MonoException * D.23206;
  guint64 D.23207;

  if (b == 0) goto <D.23204>; else goto <D.23205>;
  <D.23204>:
  D.23206 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23206);
  <D.23205>:
  D.23207 = a / b;
  return D.23207;
}


mono_llrem_un (guint64 a, guint64 b)
{
  struct MonoException * D.23211;
  guint64 D.23212;

  if (b == 0) goto <D.23209>; else goto <D.23210>;
  <D.23209>:
  D.23211 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23211);
  <D.23210>:
  D.23212 = a % b;
  return D.23212;
}


mono_lshl (guint64 a, gint32 shamt)
{
  guint64 D.23214;
  guint64 res;

  res = a << shamt;
  D.23214 = res;
  return D.23214;
}


mono_lshr_un (guint64 a, gint32 shamt)
{
  guint64 D.23216;
  guint64 res;

  res = a >> shamt;
  D.23216 = res;
  return D.23216;
}


mono_lshr (gint64 a, gint32 shamt)
{
  gint64 D.23218;
  gint64 res;

  res = a >> shamt;
  D.23218 = res;
  return D.23218;
}


mono_array_new_va (struct MonoMethod * cm)
{
  struct MonoMethodSignature * D.23220;
  short unsigned int D.23221;
  struct MonoClass * D.23222;
  unsigned char D.23223;
  unsigned int pcount.2;
  unsigned int D.23225;
  unsigned int i.3;
  unsigned int D.23227;
  uintptr_t * D.23228;
  void * ap.4;
  void * ap.5;
  unsigned int d.6;
  unsigned char D.23234;
  unsigned int rank.7;
  unsigned int D.23238;
  int D.23241;
  _Bool D.23242;
  long int D.23243;
  long int D.23244;
  struct MonoArray * D.23247;
  struct MonoDomain * domain;
  void * ap;
  uintptr_t * lengths;
  intptr_t * lower_bounds;
  int pcount;
  int rank;
  int i;
  int d;

  try
    {
      domain = mono_domain_get ();
      D.23220 = mono_method_signature (cm);
      D.23221 = D.23220->param_count;
      pcount = (int) D.23221;
      D.23222 = cm->klass;
      D.23223 = D.23222->rank;
      rank = (int) D.23223;
      __builtin_va_start (&ap, 0);
      pcount.2 = (unsigned int) pcount;
      D.23225 = pcount.2 * 4;
      lengths = __builtin_alloca (D.23225);
      i = 0;
      goto <D.22886>;
      <D.22885>:
      i.3 = (unsigned int) i;
      D.23227 = i.3 * 4;
      D.23228 = lengths + D.23227;
      ap.4 = ap;
      ap.5 = ap.4 + 4;
      ap = ap.5;
      d = MEM[(int *)ap.4];
      d.6 = (unsigned int) d;
      *D.23228 = d.6;
      i = i + 1;
      <D.22886>:
      if (i < pcount) goto <D.22885>; else goto <D.22887>;
      <D.22887>:
      if (rank == pcount) goto <D.23232>; else goto <D.23233>;
      <D.23232>:
      D.23222 = cm->klass;
      D.23234 = D.23222->byval_arg.type;
      if (D.23234 == 20) goto <D.23235>; else goto <D.23236>;
      <D.23235>:
      rank.7 = (unsigned int) rank;
      D.23238 = rank.7 * 4;
      lower_bounds = __builtin_alloca (D.23238);
      rank.7 = (unsigned int) rank;
      D.23238 = rank.7 * 4;
      memset (lower_bounds, 0, D.23238);
      goto <D.23239>;
      <D.23236>:
      lower_bounds = 0B;
      <D.23239>:
      goto <D.23240>;
      <D.23233>:
      D.23241 = rank * 2;
      D.23242 = D.23241 != pcount;
      D.23243 = (long int) D.23242;
      D.23244 = __builtin_expect (D.23243, 0);
      if (D.23244 != 0) goto <D.23245>; else goto <D.23246>;
      <D.23245>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 670, "pcount == (rank * 2)");
      <D.23246>:
      lower_bounds = lengths;
      rank.7 = (unsigned int) rank;
      D.23238 = rank.7 * 4;
      lengths = lengths + D.23238;
      <D.23240>:
      __builtin_va_end (&ap);
      D.23222 = cm->klass;
      D.23247 = mono_array_new_full (domain, D.23222, lengths, lower_bounds);
      return D.23247;
    }
  finally
    {
      ap = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23252;
  int D.23257;
  void * D.23259;
  unsigned int D.23260;

  D.23252 = __builtin_constant_p (__len);
  if (D.23252 != 0) goto <D.23253>; else goto <D.23254>;
  <D.23253>:
  if (__len == 0) goto <D.23255>; else goto <D.23256>;
  <D.23255>:
  D.23257 = __builtin_constant_p (__ch);
  if (D.23257 == 0) goto <D.23250>; else goto <D.23258>;
  <D.23258>:
  if (__ch != 0) goto <D.23250>; else goto <D.23251>;
  <D.23250>:
  __warn_memset_zero_len ();
  D.23259 = __dest;
  return D.23259;
  <D.23251>:
  <D.23256>:
  <D.23254>:
  D.23260 = __builtin_object_size (__dest, 0);
  D.23259 = __builtin___memset_chk (__dest, __ch, __len, D.23260);
  return D.23259;
}


mono_array_new_1 (struct MonoMethod * cm, guint32 length)
{
  struct MonoMethodSignature * D.23262;
  short unsigned int D.23263;
  struct MonoClass * D.23264;
  unsigned char D.23265;
  _Bool D.23266;
  long int D.23267;
  long int D.23268;
  unsigned char D.23271;
  unsigned int rank.8;
  unsigned int D.23275;
  struct MonoArray * D.23277;
  struct MonoDomain * domain;
  uintptr_t lengths[1];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23262 = mono_method_signature (cm);
      D.23263 = D.23262->param_count;
      pcount = (int) D.23263;
      D.23264 = cm->klass;
      D.23265 = D.23264->rank;
      rank = (int) D.23265;
      lengths[0] = length;
      D.23266 = rank != pcount;
      D.23267 = (long int) D.23266;
      D.23268 = __builtin_expect (D.23267, 0);
      if (D.23268 != 0) goto <D.23269>; else goto <D.23270>;
      <D.23269>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 697, "rank == pcount");
      <D.23270>:
      D.23264 = cm->klass;
      D.23271 = D.23264->byval_arg.type;
      if (D.23271 == 20) goto <D.23272>; else goto <D.23273>;
      <D.23272>:
      rank.8 = (unsigned int) rank;
      D.23275 = rank.8 * 4;
      lower_bounds = __builtin_alloca (D.23275);
      rank.8 = (unsigned int) rank;
      D.23275 = rank.8 * 4;
      memset (lower_bounds, 0, D.23275);
      goto <D.23276>;
      <D.23273>:
      lower_bounds = 0B;
      <D.23276>:
      D.23264 = cm->klass;
      D.23277 = mono_array_new_full (domain, D.23264, &lengths, lower_bounds);
      return D.23277;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_2 (struct MonoMethod * cm, guint32 length1, guint32 length2)
{
  struct MonoMethodSignature * D.23280;
  short unsigned int D.23281;
  struct MonoClass * D.23282;
  unsigned char D.23283;
  _Bool D.23284;
  long int D.23285;
  long int D.23286;
  unsigned char D.23289;
  unsigned int rank.9;
  unsigned int D.23293;
  struct MonoArray * D.23295;
  struct MonoDomain * domain;
  uintptr_t lengths[2];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23280 = mono_method_signature (cm);
      D.23281 = D.23280->param_count;
      pcount = (int) D.23281;
      D.23282 = cm->klass;
      D.23283 = D.23282->rank;
      rank = (int) D.23283;
      lengths[0] = length1;
      lengths[1] = length2;
      D.23284 = rank != pcount;
      D.23285 = (long int) D.23284;
      D.23286 = __builtin_expect (D.23285, 0);
      if (D.23286 != 0) goto <D.23287>; else goto <D.23288>;
      <D.23287>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 726, "rank == pcount");
      <D.23288>:
      D.23282 = cm->klass;
      D.23289 = D.23282->byval_arg.type;
      if (D.23289 == 20) goto <D.23290>; else goto <D.23291>;
      <D.23290>:
      rank.9 = (unsigned int) rank;
      D.23293 = rank.9 * 4;
      lower_bounds = __builtin_alloca (D.23293);
      rank.9 = (unsigned int) rank;
      D.23293 = rank.9 * 4;
      memset (lower_bounds, 0, D.23293);
      goto <D.23294>;
      <D.23291>:
      lower_bounds = 0B;
      <D.23294>:
      D.23282 = cm->klass;
      D.23295 = mono_array_new_full (domain, D.23282, &lengths, lower_bounds);
      return D.23295;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_3 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3)
{
  struct MonoMethodSignature * D.23298;
  short unsigned int D.23299;
  struct MonoClass * D.23300;
  unsigned char D.23301;
  _Bool D.23302;
  long int D.23303;
  long int D.23304;
  unsigned char D.23307;
  unsigned int rank.10;
  unsigned int D.23311;
  struct MonoArray * D.23313;
  struct MonoDomain * domain;
  uintptr_t lengths[3];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23298 = mono_method_signature (cm);
      D.23299 = D.23298->param_count;
      pcount = (int) D.23299;
      D.23300 = cm->klass;
      D.23301 = D.23300->rank;
      rank = (int) D.23301;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      D.23302 = rank != pcount;
      D.23303 = (long int) D.23302;
      D.23304 = __builtin_expect (D.23303, 0);
      if (D.23304 != 0) goto <D.23305>; else goto <D.23306>;
      <D.23305>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 756, "rank == pcount");
      <D.23306>:
      D.23300 = cm->klass;
      D.23307 = D.23300->byval_arg.type;
      if (D.23307 == 20) goto <D.23308>; else goto <D.23309>;
      <D.23308>:
      rank.10 = (unsigned int) rank;
      D.23311 = rank.10 * 4;
      lower_bounds = __builtin_alloca (D.23311);
      rank.10 = (unsigned int) rank;
      D.23311 = rank.10 * 4;
      memset (lower_bounds, 0, D.23311);
      goto <D.23312>;
      <D.23309>:
      lower_bounds = 0B;
      <D.23312>:
      D.23300 = cm->klass;
      D.23313 = mono_array_new_full (domain, D.23300, &lengths, lower_bounds);
      return D.23313;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_4 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
{
  struct MonoMethodSignature * D.23316;
  short unsigned int D.23317;
  struct MonoClass * D.23318;
  unsigned char D.23319;
  _Bool D.23320;
  long int D.23321;
  long int D.23322;
  unsigned char D.23325;
  unsigned int rank.11;
  unsigned int D.23329;
  struct MonoArray * D.23331;
  struct MonoDomain * domain;
  uintptr_t lengths[4];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23316 = mono_method_signature (cm);
      D.23317 = D.23316->param_count;
      pcount = (int) D.23317;
      D.23318 = cm->klass;
      D.23319 = D.23318->rank;
      rank = (int) D.23319;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      lengths[3] = length4;
      D.23320 = rank != pcount;
      D.23321 = (long int) D.23320;
      D.23322 = __builtin_expect (D.23321, 0);
      if (D.23322 != 0) goto <D.23323>; else goto <D.23324>;
      <D.23323>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 787, "rank == pcount");
      <D.23324>:
      D.23318 = cm->klass;
      D.23325 = D.23318->byval_arg.type;
      if (D.23325 == 20) goto <D.23326>; else goto <D.23327>;
      <D.23326>:
      rank.11 = (unsigned int) rank;
      D.23329 = rank.11 * 4;
      lower_bounds = __builtin_alloca (D.23329);
      rank.11 = (unsigned int) rank;
      D.23329 = rank.11 * 4;
      memset (lower_bounds, 0, D.23329);
      goto <D.23330>;
      <D.23327>:
      lower_bounds = 0B;
      <D.23330>:
      D.23318 = cm->klass;
      D.23331 = mono_array_new_full (domain, D.23318, &lengths, lower_bounds);
      return D.23331;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_class_static_field_address (struct MonoDomain * domain, struct MonoClassField * field)
{
  struct MonoClass * D.23334;
  unsigned int D.23335;
  unsigned int D.23336;
  struct GHashTable * D.23341;
  unsigned int addr.12;
  void * D.23345;
  int D.23346;
  sizetype D.23347;
  void * D.23348;
  struct MonoVTable * vtable;
  void * addr;

  D.23334 = field->parent;
  mono_class_init (D.23334);
  D.23334 = field->parent;
  vtable = mono_class_vtable_full (domain, D.23334, 1);
  D.23335 = BIT_FIELD_REF <*vtable, 32, 160>;
  D.23336 = D.23335 & 33554432;
  if (D.23336 == 0) goto <D.23337>; else goto <D.23338>;
  <D.23337>:
  mono_runtime_class_init (vtable);
  <D.23338>:
  D.23341 = domain->special_static_fields;
  if (D.23341 != 0B) goto <D.23342>; else goto <D.23339>;
  <D.23342>:
  D.23341 = domain->special_static_fields;
  addr = monoeg_g_hash_table_lookup (D.23341, field);
  if (addr != 0B) goto <D.23343>; else goto <D.23339>;
  <D.23343>:
  addr.12 = (unsigned int) addr;
  addr = mono_get_special_static_data (addr.12);
  goto <D.23340>;
  <D.23339>:
  D.23345 = mono_vtable_get_static_field_data (vtable);
  D.23346 = field->offset;
  D.23347 = (sizetype) D.23346;
  addr = D.23345 + D.23347;
  <D.23340>:
  D.23348 = addr;
  return D.23348;
}


mono_ldtoken_wrapper (struct MonoImage * image, int token, struct MonoGenericContext * context)
{
  unsigned int token.13;
  struct MonoClass * handle_class.14;
  void * D.23352;
  struct MonoClass * handle_class;
  void * res;

  try
    {
      token.13 = (unsigned int) token;
      res = mono_ldtoken (image, token.13, &handle_class, context);
      handle_class.14 = handle_class;
      mono_class_init (handle_class.14);
      D.23352 = res;
      return D.23352;
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


mono_ldtoken_wrapper_generic_shared (struct MonoImage * image, int token, struct MonoMethod * method)
{
  unsigned int D.23355;
  unsigned int D.23356;
  _Bool D.23360;
  long int D.23361;
  long int D.23362;
  void * D.23365;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;

  sig = mono_method_signature (method);
  D.23355 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23356 = D.23355 & 33554432;
  if (D.23356 != 0) goto <D.23357>; else goto <D.23358>;
  <D.23357>:
  generic_context = mono_method_get_context (method);
  goto <D.23359>;
  <D.23358>:
  {
    struct MonoGenericContainer * generic_container;

    generic_container = mono_method_get_generic_container (method);
    D.23360 = generic_container == 0B;
    D.23361 = (long int) D.23360;
    D.23362 = __builtin_expect (D.23361, 0);
    if (D.23362 != 0) goto <D.23363>; else goto <D.23364>;
    <D.23363>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 848, "generic_container");
    <D.23364>:
    generic_context = &generic_container->context;
  }
  <D.23359>:
  D.23365 = mono_ldtoken_wrapper (image, token, generic_context);
  return D.23365;
}


mono_fconv_u8 (double v)
{
  guint64 D.23367;

  D.23367 = (guint64) v;
  return D.23367;
}


mono_fconv_i8 (double v)
{
  gint64 D.23369;

  D.23369 = (gint64) v;
  return D.23369;
}


mono_fconv_u4 (double v)
{
  int D.23373;
  int D.23375;
  guint32 D.23376;

  D.23373 = __isinf (v);
  if (D.23373 != 0) goto <D.23371>; else goto <D.23374>;
  <D.23374>:
  D.23375 = __isnan (v);
  if (D.23375 != 0) goto <D.23371>; else goto <D.23372>;
  <D.23371>:
  D.23376 = 0;
  return D.23376;
  <D.23372>:
  D.23376 = (guint32) v;
  return D.23376;
}


mono_fconv_ovf_i8 (double v)
{
  int D.23380;
  double D.23382;
  double D.23383;
  struct MonoException * D.23384;
  gint64 D.23385;
  gint64 res;

  res = (gint64) v;
  D.23380 = __isnan (v);
  if (D.23380 != 0) goto <D.23378>; else goto <D.23381>;
  <D.23381>:
  D.23382 = trunc (v);
  D.23383 = (double) res;
  if (D.23382 != D.23383) goto <D.23378>; else goto <D.23379>;
  <D.23378>:
  D.23384 = mono_get_exception_overflow ();
  mono_raise_exception (D.23384);
  <D.23379>:
  D.23385 = res;
  return D.23385;
}


mono_fconv_ovf_u8 (double v)
{
  int D.23389;
  double D.23391;
  double D.23392;
  struct MonoException * D.23393;
  guint64 D.23394;
  guint64 res;

  res = (guint64) v;
  D.23389 = __isnan (v);
  if (D.23389 != 0) goto <D.23387>; else goto <D.23390>;
  <D.23390>:
  D.23391 = trunc (v);
  D.23392 = (double) res;
  if (D.23391 != D.23392) goto <D.23387>; else goto <D.23388>;
  <D.23387>:
  D.23393 = mono_get_exception_overflow ();
  mono_raise_exception (D.23393);
  <D.23388>:
  D.23394 = res;
  return D.23394;
}


mono_lconv_to_r8 (gint64 a)
{
  double D.23396;

  D.23396 = (double) a;
  return D.23396;
}


mono_lconv_to_r4 (gint64 a)
{
  float D.23398;

  D.23398 = (float) a;
  return D.23398;
}


mono_lconv_to_r8_un (guint64 a)
{
  double D.23400;

  D.23400 = (double) a;
  return D.23400;
}


mono_helper_compile_generic_method (struct MonoObject * obj, struct MonoMethod * method, void * * this_arg)
{
  int D.23402;
  int D.23403;
  struct MonoException * D.23406;
  struct MonoClass * D.23407;
  struct MonoGenericContainer * D.23408;
  _Bool D.23409;
  long int D.23410;
  long int D.23411;
  int iftmp.15;
  struct MonoGenericClass * D.23417;
  struct MonoGenericInst * D.23419;
  unsigned int D.23420;
  unsigned int D.23421;
  _Bool D.23423;
  long int D.23424;
  long int D.23425;
  int iftmp.16;
  struct MonoGenericInst * D.23431;
  unsigned int D.23433;
  unsigned int D.23434;
  _Bool D.23436;
  long int D.23437;
  long int D.23438;
  int D.23441;
  struct MonoVTable * D.23442;
  struct MonoClass * D.23443;
  unsigned int D.23444;
  unsigned int D.23445;
  void * D.23448;
  void * D.23450;
  struct MonoMethod * vmethod;
  void * addr;
  struct MonoGenericContext * context;

  context = mono_method_get_context (method);
  D.23402 = mono_jit_stats.generic_virtual_invocations;
  D.23403 = D.23402 + 1;
  mono_jit_stats.generic_virtual_invocations = D.23403;
  if (obj == 0B) goto <D.23404>; else goto <D.23405>;
  <D.23404>:
  D.23406 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23406);
  <D.23405>:
  vmethod = mono_object_get_virtual_method (obj, method);
  D.23407 = vmethod->klass;
  D.23408 = D.23407->generic_container;
  D.23409 = D.23408 != 0B;
  D.23410 = (long int) D.23409;
  D.23411 = __builtin_expect (D.23410, 0);
  if (D.23411 != 0) goto <D.23412>; else goto <D.23413>;
  <D.23412>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 993, "!vmethod->klass->generic_container");
  <D.23413>:
  D.23407 = vmethod->klass;
  D.23417 = D.23407->generic_class;
  if (D.23417 != 0B) goto <D.23418>; else goto <D.23415>;
  <D.23418>:
  D.23407 = vmethod->klass;
  D.23417 = D.23407->generic_class;
  D.23419 = D.23417->context.class_inst;
  D.23420 = BIT_FIELD_REF <*D.23419, 32, 32>;
  D.23421 = D.23420 & 4194304;
  if (D.23421 != 0) goto <D.23422>; else goto <D.23415>;
  <D.23422>:
  iftmp.15 = 1;
  goto <D.23416>;
  <D.23415>:
  iftmp.15 = 0;
  <D.23416>:
  D.23423 = iftmp.15 != 0;
  D.23424 = (long int) D.23423;
  D.23425 = __builtin_expect (D.23424, 0);
  if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
  <D.23426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 994, "!vmethod->klass->generic_class || !vmethod->klass->generic_class->context.class_inst->is_open");
  <D.23427>:
  D.23431 = context->method_inst;
  if (D.23431 != 0B) goto <D.23432>; else goto <D.23429>;
  <D.23432>:
  D.23431 = context->method_inst;
  D.23433 = BIT_FIELD_REF <*D.23431, 32, 32>;
  D.23434 = D.23433 & 4194304;
  if (D.23434 != 0) goto <D.23435>; else goto <D.23429>;
  <D.23435>:
  iftmp.16 = 1;
  goto <D.23430>;
  <D.23429>:
  iftmp.16 = 0;
  <D.23430>:
  D.23436 = iftmp.16 != 0;
  D.23437 = (long int) D.23436;
  D.23438 = __builtin_expect (D.23437, 0);
  if (D.23438 != 0) goto <D.23439>; else goto <D.23440>;
  <D.23439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 995, "!context->method_inst || !context->method_inst->is_open");
  <D.23440>:
  addr = mono_compile_method (vmethod);
  D.23441 = mono_method_needs_static_rgctx_invoke (vmethod, 0);
  addr = mini_add_method_trampoline (0B, vmethod, addr, D.23441, 0);
  D.23442 = obj->vtable;
  D.23443 = D.23442->klass;
  D.23444 = BIT_FIELD_REF <*D.23443, 32, 160>;
  D.23445 = D.23444 & 8;
  if (D.23445 != 0) goto <D.23446>; else goto <D.23447>;
  <D.23446>:
  D.23448 = mono_object_unbox (obj);
  *this_arg = D.23448;
  goto <D.23449>;
  <D.23447>:
  *this_arg = obj;
  <D.23449>:
  D.23450 = addr;
  return D.23450;
}


mono_helper_ldstr (struct MonoImage * image, guint32 idx)
{
  struct MonoString * D.23452;
  struct MonoDomain * D.23453;

  D.23453 = mono_domain_get ();
  D.23452 = mono_ldstr (D.23453, image, idx);
  return D.23452;
}


mono_helper_ldstr_mscorlib (guint32 idx)
{
  struct MonoString * D.23455;
  struct MonoDomain * D.23456;
  struct MonoImage * D.23457;

  D.23456 = mono_domain_get ();
  D.23457 = mono_defaults.corlib;
  D.23455 = mono_ldstr (D.23456, D.23457, idx);
  return D.23455;
}


mono_helper_newobj_mscorlib (guint32 idx)
{
  struct MonoImage * D.23459;
  unsigned int D.23460;
  _Bool D.23461;
  long int D.23462;
  long int D.23463;
  struct MonoObject * D.23466;
  struct MonoDomain * D.23467;
  struct MonoClass * klass;

  D.23459 = mono_defaults.corlib;
  D.23460 = idx | 33554432;
  klass = mono_class_get (D.23459, D.23460);
  D.23461 = klass == 0B;
  D.23462 = (long int) D.23461;
  D.23463 = __builtin_expect (D.23462, 0);
  if (D.23463 != 0) goto <D.23464>; else goto <D.23465>;
  <D.23464>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1027, "klass");
  <D.23465>:
  D.23467 = mono_domain_get ();
  D.23466 = mono_object_new (D.23467, klass);
  return D.23466;
}


mono_break ()
{

}


mono_create_corlib_exception_0 (guint32 token)
{
  struct MonoException * D.23469;
  struct MonoImage * D.23470;

  D.23470 = mono_defaults.corlib;
  D.23469 = mono_exception_from_token (D.23470, token);
  return D.23469;
}


mono_create_corlib_exception_1 (guint32 token, struct MonoString * arg)
{
  struct MonoException * D.23472;
  struct MonoImage * D.23473;

  D.23473 = mono_defaults.corlib;
  D.23472 = mono_exception_from_token_two_strings (D.23473, token, arg, 0B);
  return D.23472;
}


mono_create_corlib_exception_2 (guint32 token, struct MonoString * arg1, struct MonoString * arg2)
{
  struct MonoException * D.23475;
  struct MonoImage * D.23476;

  D.23476 = mono_defaults.corlib;
  D.23475 = mono_exception_from_token_two_strings (D.23476, token, arg1, arg2);
  return D.23475;
}


mono_object_castclass_unbox (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoDebugOptions * D.23478;
  int D.23479;
  unsigned int mono_jit_tls_id.17;
  struct MonoObject * D.23485;
  unsigned int D.23486;
  unsigned int D.23487;
  struct MonoVTable * D.23490;
  struct MonoClass * D.23491;
  struct MonoClass * D.23492;
  struct MonoObject * D.23495;
  struct MonoDebugOptions * D.23498;
  int D.23499;
  struct MonoImage * D.23502;
  struct MonoException * D.23503;
  struct MonoJitTlsData * jit_tls;

  jit_tls = 0B;
  D.23478 = mini_get_debug_options ();
  D.23479 = D.23478->better_cast_details;
  if (D.23479 != 0) goto <D.23480>; else goto <D.23481>;
  <D.23480>:
  mono_jit_tls_id.17 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.17);
  jit_tls->class_cast_from = 0B;
  <D.23481>:
  if (obj == 0B) goto <D.23483>; else goto <D.23484>;
  <D.23483>:
  D.23485 = 0B;
  return D.23485;
  <D.23484>:
  D.23486 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23487 = D.23486 & 16;
  if (D.23487 != 0) goto <D.23488>; else goto <D.23489>;
  <D.23488>:
  D.23490 = obj->vtable;
  D.23491 = D.23490->klass;
  D.23492 = klass->element_class;
  if (D.23491 == D.23492) goto <D.23493>; else goto <D.23494>;
  <D.23493>:
  D.23485 = obj;
  return D.23485;
  <D.23494>:
  <D.23489>:
  D.23495 = mono_object_isinst (obj, klass);
  if (D.23495 != 0B) goto <D.23496>; else goto <D.23497>;
  <D.23496>:
  D.23485 = obj;
  return D.23485;
  <D.23497>:
  D.23498 = mini_get_debug_options ();
  D.23499 = D.23498->better_cast_details;
  if (D.23499 != 0) goto <D.23500>; else goto <D.23501>;
  <D.23500>:
  D.23490 = obj->vtable;
  D.23491 = D.23490->klass;
  jit_tls->class_cast_from = D.23491;
  jit_tls->class_cast_to = klass;
  <D.23501>:
  D.23502 = mono_defaults.corlib;
  D.23503 = mono_exception_from_name (D.23502, "System", "InvalidCastException");
  mono_raise_exception (D.23503);
  D.23485 = 0B;
  return D.23485;
}


mono_object_castclass_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoDebugOptions * D.23505;
  int D.23506;
  unsigned int mono_jit_tls_id.18;
  struct MonoObject * D.23512;
  struct MonoObject * D.23515;
  struct MonoDebugOptions * D.23518;
  int D.23519;
  struct MonoVTable * D.23522;
  struct MonoClass * D.23523;
  struct MonoImage * D.23524;
  struct MonoException * D.23525;
  struct MonoJitTlsData * jit_tls;
  void * cached_vtable;
  void * obj_vtable;

  jit_tls = 0B;
  D.23505 = mini_get_debug_options ();
  D.23506 = D.23505->better_cast_details;
  if (D.23506 != 0) goto <D.23507>; else goto <D.23508>;
  <D.23507>:
  mono_jit_tls_id.18 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.18);
  jit_tls->class_cast_from = 0B;
  <D.23508>:
  if (obj == 0B) goto <D.23510>; else goto <D.23511>;
  <D.23510>:
  D.23512 = 0B;
  return D.23512;
  <D.23511>:
  cached_vtable = *cache;
  obj_vtable = obj->vtable;
  if (cached_vtable == obj_vtable) goto <D.23513>; else goto <D.23514>;
  <D.23513>:
  D.23512 = obj;
  return D.23512;
  <D.23514>:
  D.23515 = mono_object_isinst (obj, klass);
  if (D.23515 != 0B) goto <D.23516>; else goto <D.23517>;
  <D.23516>:
  *cache = obj_vtable;
  D.23512 = obj;
  return D.23512;
  <D.23517>:
  D.23518 = mini_get_debug_options ();
  D.23519 = D.23518->better_cast_details;
  if (D.23519 != 0) goto <D.23520>; else goto <D.23521>;
  <D.23520>:
  D.23522 = obj->vtable;
  D.23523 = D.23522->klass;
  jit_tls->class_cast_from = D.23523;
  jit_tls->class_cast_to = klass;
  <D.23521>:
  D.23524 = mono_defaults.corlib;
  D.23525 = mono_exception_from_name (D.23524, "System", "InvalidCastException");
  mono_raise_exception (D.23525);
  D.23512 = 0B;
  return D.23512;
}


mono_object_isinst_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoObject * D.23529;
  void * D.23530;
  struct MonoVTable * D.23531;
  unsigned int D.23532;
  struct MonoObject * iftmp.19;
  unsigned int D.23536;
  struct MonoObject * D.23540;
  void * obj_vtable.20;
  unsigned int D.23544;
  void * D.23545;
  size_t cached_vtable;
  size_t obj_vtable;

  if (obj == 0B) goto <D.23527>; else goto <D.23528>;
  <D.23527>:
  D.23529 = 0B;
  return D.23529;
  <D.23528>:
  D.23530 = *cache;
  cached_vtable = (size_t) D.23530;
  D.23531 = obj->vtable;
  obj_vtable = (size_t) D.23531;
  D.23532 = cached_vtable & 4294967294;
  if (D.23532 == obj_vtable) goto <D.23533>; else goto <D.23534>;
  <D.23533>:
  D.23536 = cached_vtable & 1;
  if (D.23536 == 0) goto <D.23537>; else goto <D.23538>;
  <D.23537>:
  iftmp.19 = obj;
  goto <D.23539>;
  <D.23538>:
  iftmp.19 = 0B;
  <D.23539>:
  D.23529 = iftmp.19;
  return D.23529;
  <D.23534>:
  D.23540 = mono_object_isinst (obj, klass);
  if (D.23540 != 0B) goto <D.23541>; else goto <D.23542>;
  <D.23541>:
  obj_vtable.20 = (void *) obj_vtable;
  *cache = obj_vtable.20;
  D.23529 = obj;
  return D.23529;
  <D.23542>:
  D.23544 = obj_vtable | 1;
  D.23545 = (void *) D.23544;
  *cache = D.23545;
  D.23529 = 0B;
  return D.23529;
}


mono_get_native_calli_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, void * func)
{
  short unsigned int D.23547;
  int D.23548;
  int D.23549;
  unsigned int D.23550;
  unsigned int D.23551;
  void * D.23552;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct MonoMethod * m;

  try
    {
      D.23547 = sig->param_count;
      D.23548 = (int) D.23547;
      D.23549 = D.23548 + 1;
      D.23550 = (unsigned int) D.23549;
      D.23551 = D.23550 * 4;
      mspecs = monoeg_malloc0 (D.23551);
      memset (&piinfo, 0, 32);
      m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
      D.23552 = mono_compile_method (m);
      return D.23552;
    }
  finally
    {
      piinfo = {CLOBBER};
    }
}


mono_gsharedvt_constrained_call (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, gboolean deref_arg, void * * args)
{
  void * D.23559;
  void * D.23560;
  unsigned int D.23561;
  unsigned int D.23562;
  void * this_arg.21;
  struct MonoObject * D.23566;
  struct MonoMethod * m;
  void * this_arg;
  void * new_args[16];

  try
    {
      m = constrained_gsharedvt_call_setup (mp, cmethod, klass, &this_arg);
      if (args != 0B) goto <D.23555>; else goto <D.23556>;
      <D.23555>:
      if (deref_arg != 0) goto <D.23557>; else goto <D.23558>;
      <D.23557>:
      D.23559 = *args;
      D.23560 = MEM[(void * *)D.23559];
      new_args[0] = D.23560;
      args = &new_args;
      <D.23558>:
      <D.23556>:
      D.23561 = BIT_FIELD_REF <*m, 32, 160>;
      D.23562 = D.23561 & 124;
      if (D.23562 == 24) goto <D.23563>; else goto <D.23564>;
      <D.23563>:
      args = &new_args;
      this_arg.21 = this_arg;
      *args = this_arg.21;
      this_arg = 0B;
      <D.23564>:
      this_arg.21 = this_arg;
      D.23566 = mono_runtime_invoke (m, this_arg.21, args, 0B);
      return D.23566;
    }
  finally
    {
      this_arg = {CLOBBER};
      new_args = {CLOBBER};
    }
}


constrained_gsharedvt_call_setup (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, void * * this_arg)
{
  unsigned int D.23569;
  unsigned int D.23570;
  struct MonoException * D.23573;
  struct MonoMethodSignature * D.23574;
  unsigned int D.23575;
  unsigned int D.23576;
  struct MonoMethod * * D.23580;
  _Bool D.23581;
  long int D.23582;
  long int D.23583;
  struct MonoClass * D.23586;
  unsigned int D.23587;
  unsigned int D.23588;
  _Bool D.23591;
  long int D.23592;
  long int D.23593;
  unsigned int vt_slot.22;
  unsigned int D.23597;
  struct MonoMethod * * D.23598;
  unsigned int D.23602;
  unsigned int D.23603;
  struct MonoClass * D.23605;
  struct MonoClass * D.23606;
  struct MonoClass * D.23608;
  struct MonoClass * D.23609;
  struct MonoDomain * D.23611;
  struct MonoObject * D.23612;
  void * D.23616;
  struct MonoMethod * D.23617;
  struct MonoMethod * m;
  int vt_slot;

  D.23569 = klass->flags;
  D.23570 = D.23569 & 32;
  if (D.23570 != 0) goto <D.23571>; else goto <D.23572>;
  <D.23571>:
  D.23573 = mono_get_exception_execution_engine ("Not yet supported.");
  mono_raise_exception (D.23573);
  <D.23572>:
  D.23574 = mono_method_signature (cmethod);
  D.23575 = BIT_FIELD_REF <*D.23574, 32, 64>;
  D.23576 = D.23575 & 16777216;
  if (D.23576 != 0) goto <D.23577>; else goto <D.23578>;
  <D.23577>:
  m = mono_marshal_get_native_wrapper (cmethod, 1, 0);
  goto <D.23579>;
  <D.23578>:
  mono_class_setup_vtable (klass);
  D.23580 = klass->vtable;
  D.23581 = D.23580 == 0B;
  D.23582 = (long int) D.23581;
  D.23583 = __builtin_expect (D.23582, 0);
  if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1180, "klass->vtable");
  <D.23585>:
  vt_slot = mono_method_get_vtable_slot (cmethod);
  D.23586 = cmethod->klass;
  D.23587 = D.23586->flags;
  D.23588 = D.23587 & 32;
  if (D.23588 != 0) goto <D.23589>; else goto <D.23590>;
  <D.23589>:
  {
    int iface_offset;

    D.23586 = cmethod->klass;
    iface_offset = mono_class_interface_offset (klass, D.23586);
    D.23591 = iface_offset == -1;
    D.23592 = (long int) D.23591;
    D.23593 = __builtin_expect (D.23592, 0);
    if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
    <D.23594>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1186, "iface_offset != -1");
    <D.23595>:
    vt_slot = vt_slot + iface_offset;
  }
  <D.23590>:
  D.23580 = klass->vtable;
  vt_slot.22 = (unsigned int) vt_slot;
  D.23597 = vt_slot.22 * 4;
  D.23598 = D.23580 + D.23597;
  m = *D.23598;
  <D.23579>:
  D.23602 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23603 = D.23602 & 8;
  if (D.23603 != 0) goto <D.23604>; else goto <D.23599>;
  <D.23604>:
  D.23605 = m->klass;
  D.23606 = mono_defaults.object_class;
  if (D.23605 == D.23606) goto <D.23600>; else goto <D.23607>;
  <D.23607>:
  D.23605 = m->klass;
  D.23608 = mono_defaults.enum_class;
  D.23609 = D.23608->parent;
  if (D.23605 == D.23609) goto <D.23600>; else goto <D.23610>;
  <D.23610>:
  D.23605 = m->klass;
  D.23608 = mono_defaults.enum_class;
  if (D.23605 == D.23608) goto <D.23600>; else goto <D.23599>;
  <D.23600>:
  D.23611 = mono_domain_get ();
  D.23612 = mono_value_box (D.23611, klass, mp);
  *this_arg = D.23612;
  goto <D.23601>;
  <D.23599>:
  D.23602 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23603 = D.23602 & 8;
  if (D.23603 != 0) goto <D.23613>; else goto <D.23614>;
  <D.23613>:
  *this_arg = mp;
  goto <D.23615>;
  <D.23614>:
  D.23616 = MEM[(void * *)mp];
  *this_arg = D.23616;
  <D.23615>:
  <D.23601>:
  D.23617 = m;
  return D.23617;
}


mono_gsharedvt_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  unsigned int D.23619;
  unsigned int D.23620;
  struct MonoObject * D.23624;

  D.23619 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23620 = D.23619 & 8;
  if (D.23620 != 0) goto <D.23621>; else goto <D.23622>;
  <D.23621>:
  mono_value_copy (dest, src, klass);
  goto <D.23623>;
  <D.23622>:
  D.23624 = MEM[(struct MonoObject * *)src];
  mono_gc_wbarrier_generic_store (dest, D.23624);
  <D.23623>:
}