mono_ldftn (struct MonoMethod * method)
{
  struct MonoDomain * D.23477;
  void * D.23478;
  struct MonoDomain * D.23479;
  void * addr;

  D.23477 = mono_domain_get ();
  addr = mono_create_jump_trampoline (D.23477, method, 0);
  D.23479 = mono_domain_get ();
  D.23478 = mono_create_ftnptr (D.23479, addr);
  return D.23478;
}


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

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


ldvirtfn_internal (struct MonoObject * obj, struct MonoMethod * method, gboolean gshared)
{
  struct MonoException * D.23485;
  unsigned char D.23488;
  unsigned char D.23489;
  struct MonoGenericContext * D.23492;
  struct MonoGenericInst * D.23493;
  struct MonoClass * D.23496;
  struct MonoGenericClass * D.23497;
  struct MonoGenericInst * D.23500;
  struct MonoGenericContainer * D.23502;
  struct MonoGenericInst * D.23505;
  struct MonoGenericContext * D.23506;
  struct MonoGenericInst * D.23507;
  void * D.23508;
  struct MonoMethod * res;

  if (obj == 0B) goto <D.23483>; else goto <D.23484>;
  <D.23483>:
  D.23485 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23485);
  <D.23484>:
  res = mono_object_get_virtual_method (obj, method);
  if (gshared != 0) goto <D.23486>; else goto <D.23487>;
  <D.23486>:
  D.23488 = BIT_FIELD_REF <*method, 8, 168>;
  D.23489 = D.23488 & 16;
  if (D.23489 != 0) goto <D.23490>; else goto <D.23491>;
  <D.23490>:
  D.23492 = mono_method_get_context (method);
  D.23493 = D.23492->method_inst;
  if (D.23493 != 0B) goto <D.23494>; else goto <D.23495>;
  <D.23494>:
  {
    struct MonoGenericContext context;

    try
      {
        context.class_inst = 0B;
        context.method_inst = 0B;
        D.23496 = res->klass;
        D.23497 = D.23496->generic_class;
        if (D.23497 != 0B) goto <D.23498>; else goto <D.23499>;
        <D.23498>:
        D.23496 = res->klass;
        D.23497 = D.23496->generic_class;
        D.23500 = D.23497->context.class_inst;
        context.class_inst = D.23500;
        goto <D.23501>;
        <D.23499>:
        D.23496 = res->klass;
        D.23502 = D.23496->generic_container;
        if (D.23502 != 0B) goto <D.23503>; else goto <D.23504>;
        <D.23503>:
        D.23496 = res->klass;
        D.23502 = D.23496->generic_container;
        D.23505 = D.23502->context.class_inst;
        context.class_inst = D.23505;
        <D.23504>:
        <D.23501>:
        D.23506 = mono_method_get_context (method);
        D.23507 = D.23506->method_inst;
        context.method_inst = D.23507;
        res = mono_class_inflate_generic_method (res, &context);
      }
    finally
      {
        context = {CLOBBER};
      }
  }
  <D.23495>:
  <D.23491>:
  <D.23487>:
  D.23508 = mono_ldftn (res);
  return D.23508;
}


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

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


mono_helper_stelem_ref_check (struct MonoArray * array, struct MonoObject * val)
{
  struct MonoException * D.23514;
  struct MonoVTable * D.23517;
  struct MonoClass * D.23518;
  struct MonoClass * D.23519;
  struct MonoObject * D.23520;
  struct MonoException * D.23523;

  if (array == 0B) goto <D.23512>; else goto <D.23513>;
  <D.23512>:
  D.23514 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23514);
  <D.23513>:
  if (val != 0B) goto <D.23515>; else goto <D.23516>;
  <D.23515>:
  D.23517 = array->obj.vtable;
  D.23518 = D.23517->klass;
  D.23519 = D.23518->element_class;
  D.23520 = mono_object_isinst (val, D.23519);
  if (D.23520 == 0B) goto <D.23521>; else goto <D.23522>;
  <D.23521>:
  D.23523 = mono_get_exception_array_type_mismatch ();
  mono_raise_exception (D.23523);
  <D.23522>:
  <D.23516>:
}


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

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


mono_llmult_ovf_un (guint64 a, guint64 b)
{
  long long unsigned int D.23526;
  long long unsigned int D.23527;
  _Bool D.23528;
  _Bool D.23529;
  _Bool D.23530;
  long long unsigned int D.23532;
  long long unsigned int D.23533;
  long long unsigned int D.23534;
  long long unsigned int D.23535;
  long long unsigned int D.23536;
  long long unsigned int D.23537;
  long long unsigned int D.23539;
  guint64 D.23540;
  struct MonoException * D.23541;
  guint32 al;
  guint32 ah;
  guint32 bl;
  guint32 bh;
  guint64 res;
  guint64 t1;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.23526 = a >> 32;
  ah = (guint32) D.23526;
  bl = (guint32) b;
  D.23527 = b >> 32;
  bh = (guint32) D.23527;
  D.23528 = ah != 0;
  D.23529 = bh != 0;
  D.23530 = D.23528 & D.23529;
  if (D.23530 != 0) goto raise_exception; else goto <D.23531>;
  <D.23531>:
  D.23532 = (long long unsigned int) al;
  D.23533 = (long long unsigned int) bl;
  res = D.23532 * D.23533;
  D.23534 = (long long unsigned int) ah;
  D.23533 = (long long unsigned int) bl;
  D.23535 = D.23534 * D.23533;
  D.23532 = (long long unsigned int) al;
  D.23536 = (long long unsigned int) bh;
  D.23537 = D.23532 * D.23536;
  t1 = D.23535 + D.23537;
  if (t1 > 4294967295) goto raise_exception; else goto <D.23538>;
  <D.23538>:
  D.23539 = t1 << 32;
  res = D.23539 + res;
  D.23540 = res;
  return D.23540;
  raise_exception:
  D.23541 = mono_get_exception_overflow ();
  mono_raise_exception (D.23541);
  D.23540 = 0;
  return D.23540;
}


mono_llmult_ovf (gint64 a, gint64 b)
{
  long long int D.23543;
  long long int D.23544;
  _Bool D.23547;
  _Bool D.23548;
  _Bool D.23549;
  guint64 D.23554;
  _Bool D.23561;
  _Bool D.23562;
  _Bool D.23563;
  _Bool D.23572;
  _Bool D.23573;
  _Bool D.23574;
  long long int D.23576;
  long long int D.23577;
  long long int D.23578;
  long long int D.23580;
  long long int D.23581;
  long long int D.23582;
  unsigned int ah.0;
  unsigned int D.23585;
  long long int D.23586;
  unsigned int bh.1;
  unsigned int D.23588;
  long long int D.23589;
  long long int D.23590;
  long long int D.23591;
  long long int D.23596;
  struct MonoException * D.23597;
  guint32 al;
  gint32 ah;
  guint32 bl;
  gint32 bh;
  gint64 res;
  gint64 t1;
  gint32 sign;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.23543 = a >> 32;
  ah = (gint32) D.23543;
  bl = (guint32) b;
  D.23544 = b >> 32;
  bh = (gint32) D.23544;
  sign = ah ^ bh;
  if (ah < 0) goto <D.23545>; else goto <D.23546>;
  <D.23545>:
  D.23547 = ah == -2147483648;
  D.23548 = al == 0;
  D.23549 = D.23547 & D.23548;
  if (D.23549 != 0) goto <D.23550>; else goto <D.23551>;
  <D.23550>:
  if (b == 0) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  D.23554 = 0;
  return D.23554;
  <D.23553>:
  if (b == 1) goto <D.23555>; else goto raise_exception;
  <D.23555>:
  D.23554 = (guint64) a;
  return D.23554;
  <D.23551>:
  ah = ~ah;
  if (al == 0) goto <D.23556>; else goto <D.23557>;
  <D.23556>:
  ah = ah + 1;
  goto <D.23558>;
  <D.23557>:
  al = ~al;
  al = al + 1;
  <D.23558>:
  <D.23546>:
  if (bh < 0) goto <D.23559>; else goto <D.23560>;
  <D.23559>:
  D.23561 = bh == -2147483648;
  D.23562 = bl == 0;
  D.23563 = D.23561 & D.23562;
  if (D.23563 != 0) goto <D.23564>; else goto <D.23565>;
  <D.23564>:
  if (a == 0) goto <D.23566>; else goto <D.23567>;
  <D.23566>:
  D.23554 = 0;
  return D.23554;
  <D.23567>:
  if (a == 1) goto <D.23568>; else goto raise_exception;
  <D.23568>:
  D.23554 = (guint64) b;
  return D.23554;
  <D.23565>:
  bh = ~bh;
  if (bl == 0) goto <D.23569>; else goto <D.23570>;
  <D.23569>:
  bh = bh + 1;
  goto <D.23571>;
  <D.23570>:
  bl = ~bl;
  bl = bl + 1;
  <D.23571>:
  <D.23560>:
  D.23572 = ah != 0;
  D.23573 = bh != 0;
  D.23574 = D.23572 & D.23573;
  if (D.23574 != 0) goto raise_exception; else goto <D.23575>;
  <D.23575>:
  D.23576 = (long long int) ah;
  D.23577 = (long long int) bl;
  D.23578 = D.23576 * D.23577;
  if (D.23578 > 2147483648) goto raise_exception; else goto <D.23579>;
  <D.23579>:
  D.23580 = (long long int) al;
  D.23581 = (long long int) bh;
  D.23582 = D.23580 * D.23581;
  if (D.23582 > 2147483648) goto raise_exception; else goto <D.23583>;
  <D.23583>:
  D.23580 = (long long int) al;
  D.23577 = (long long int) bl;
  t1 = D.23580 * D.23577;
  res = t1;
  ah.0 = (unsigned int) ah;
  D.23585 = ah.0 - al;
  D.23586 = (long long int) D.23585;
  bh.1 = (unsigned int) bh;
  D.23588 = bl - bh.1;
  D.23589 = (long long int) D.23588;
  D.23590 = D.23586 * D.23589;
  t1 = D.23590 + t1;
  t1 = t1 << 32;
  D.23591 = 9223372036854775807 - res;
  if (D.23591 < t1) goto raise_exception; else goto <D.23592>;
  <D.23592>:
  res = res + t1;
  if (res < 0) goto raise_exception; else goto <D.23593>;
  <D.23593>:
  if (sign < 0) goto <D.23594>; else goto <D.23595>;
  <D.23594>:
  D.23596 = -res;
  D.23554 = (guint64) D.23596;
  return D.23554;
  <D.23595>:
  D.23554 = (guint64) res;
  return D.23554;
  raise_exception:
  D.23597 = mono_get_exception_overflow ();
  mono_raise_exception (D.23597);
  D.23554 = 0;
  return D.23554;
}


mono_lldiv (gint64 a, gint64 b)
{
  struct MonoException * D.23601;
  _Bool D.23603;
  _Bool D.23604;
  _Bool D.23605;
  struct MonoException * D.23608;
  gint64 D.23609;

  if (b == 0) goto <D.23599>; else goto <D.23600>;
  <D.23599>:
  D.23601 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23601);
  goto <D.23602>;
  <D.23600>:
  D.23603 = b == -1;
  D.23604 = a == -9223372036854775808;
  D.23605 = D.23603 & D.23604;
  if (D.23605 != 0) goto <D.23606>; else goto <D.23607>;
  <D.23606>:
  D.23608 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.23608);
  <D.23607>:
  <D.23602>:
  D.23609 = a / b;
  return D.23609;
}


mono_llrem (gint64 a, gint64 b)
{
  struct MonoException * D.23613;
  _Bool D.23615;
  _Bool D.23616;
  _Bool D.23617;
  struct MonoException * D.23620;
  gint64 D.23621;

  if (b == 0) goto <D.23611>; else goto <D.23612>;
  <D.23611>:
  D.23613 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23613);
  goto <D.23614>;
  <D.23612>:
  D.23615 = b == -1;
  D.23616 = a == -9223372036854775808;
  D.23617 = D.23615 & D.23616;
  if (D.23617 != 0) goto <D.23618>; else goto <D.23619>;
  <D.23618>:
  D.23620 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.23620);
  <D.23619>:
  <D.23614>:
  D.23621 = a % b;
  return D.23621;
}


mono_lldiv_un (guint64 a, guint64 b)
{
  struct MonoException * D.23625;
  guint64 D.23626;

  if (b == 0) goto <D.23623>; else goto <D.23624>;
  <D.23623>:
  D.23625 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23625);
  <D.23624>:
  D.23626 = a / b;
  return D.23626;
}


mono_llrem_un (guint64 a, guint64 b)
{
  struct MonoException * D.23630;
  guint64 D.23631;

  if (b == 0) goto <D.23628>; else goto <D.23629>;
  <D.23628>:
  D.23630 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.23630);
  <D.23629>:
  D.23631 = a % b;
  return D.23631;
}


mono_array_new_va (struct MonoMethod * cm)
{
  struct MonoMethodSignature * D.23633;
  short unsigned int D.23634;
  struct MonoClass * D.23635;
  unsigned char D.23636;
  unsigned int pcount.2;
  unsigned int D.23638;
  unsigned int i.3;
  unsigned int D.23640;
  uintptr_t * D.23641;
  char * ap.4;
  char * ap.5;
  unsigned int d.6;
  unsigned char D.23647;
  unsigned int rank.7;
  unsigned int D.23651;
  int D.23654;
  _Bool D.23655;
  long int D.23656;
  long int D.23657;
  struct MonoArray * D.23660;
  struct MonoDomain * domain;
  char * ap;
  uintptr_t * lengths;
  intptr_t * lower_bounds;
  int pcount;
  int rank;
  int i;
  int d;

  try
    {
      domain = mono_domain_get ();
      D.23633 = mono_method_signature (cm);
      D.23634 = D.23633->param_count;
      pcount = (int) D.23634;
      D.23635 = cm->klass;
      D.23636 = D.23635->rank;
      rank = (int) D.23636;
      __builtin_va_start (&ap, 0);
      pcount.2 = (unsigned int) pcount;
      D.23638 = pcount.2 * 4;
      lengths = __builtin_alloca (D.23638);
      i = 0;
      goto <D.23311>;
      <D.23310>:
      i.3 = (unsigned int) i;
      D.23640 = i.3 * 4;
      D.23641 = lengths + D.23640;
      ap.4 = ap;
      ap.5 = ap.4 + 4;
      ap = ap.5;
      d = MEM[(int *)ap.4];
      d.6 = (unsigned int) d;
      *D.23641 = d.6;
      i = i + 1;
      <D.23311>:
      if (i < pcount) goto <D.23310>; else goto <D.23312>;
      <D.23312>:
      if (rank == pcount) goto <D.23645>; else goto <D.23646>;
      <D.23645>:
      D.23635 = cm->klass;
      D.23647 = D.23635->byval_arg.type;
      if (D.23647 == 20) goto <D.23648>; else goto <D.23649>;
      <D.23648>:
      rank.7 = (unsigned int) rank;
      D.23651 = rank.7 * 4;
      lower_bounds = __builtin_alloca (D.23651);
      rank.7 = (unsigned int) rank;
      D.23651 = rank.7 * 4;
      memset (lower_bounds, 0, D.23651);
      goto <D.23652>;
      <D.23649>:
      lower_bounds = 0B;
      <D.23652>:
      goto <D.23653>;
      <D.23646>:
      D.23654 = rank * 2;
      D.23655 = D.23654 != pcount;
      D.23656 = (long int) D.23655;
      D.23657 = __builtin_expect (D.23656, 0);
      if (D.23657 != 0) goto <D.23658>; else goto <D.23659>;
      <D.23658>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 670, "pcount == (rank * 2)");
      <D.23659>:
      lower_bounds = lengths;
      rank.7 = (unsigned int) rank;
      D.23651 = rank.7 * 4;
      lengths = lengths + D.23651;
      <D.23653>:
      __builtin_va_end (&ap);
      D.23635 = cm->klass;
      D.23660 = mono_array_new_full (domain, D.23635, lengths, lower_bounds);
      return D.23660;
    }
  finally
    {
      ap = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23665;
  int D.23670;
  void * D.23672;
  unsigned int D.23673;

  D.23665 = __builtin_constant_p (__len);
  if (D.23665 != 0) goto <D.23666>; else goto <D.23667>;
  <D.23666>:
  if (__len == 0) goto <D.23668>; else goto <D.23669>;
  <D.23668>:
  D.23670 = __builtin_constant_p (__ch);
  if (D.23670 == 0) goto <D.23663>; else goto <D.23671>;
  <D.23671>:
  if (__ch != 0) goto <D.23663>; else goto <D.23664>;
  <D.23663>:
  __warn_memset_zero_len ();
  D.23672 = __dest;
  return D.23672;
  <D.23664>:
  <D.23669>:
  <D.23667>:
  D.23673 = __builtin_object_size (__dest, 0);
  D.23672 = __builtin___memset_chk (__dest, __ch, __len, D.23673);
  return D.23672;
}


mono_array_new_1 (struct MonoMethod * cm, guint32 length)
{
  struct MonoMethodSignature * D.23675;
  short unsigned int D.23676;
  struct MonoClass * D.23677;
  unsigned char D.23678;
  _Bool D.23679;
  long int D.23680;
  long int D.23681;
  unsigned char D.23684;
  unsigned int rank.8;
  unsigned int D.23688;
  struct MonoArray * D.23690;
  struct MonoDomain * domain;
  uintptr_t lengths[1];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23675 = mono_method_signature (cm);
      D.23676 = D.23675->param_count;
      pcount = (int) D.23676;
      D.23677 = cm->klass;
      D.23678 = D.23677->rank;
      rank = (int) D.23678;
      lengths[0] = length;
      D.23679 = rank != pcount;
      D.23680 = (long int) D.23679;
      D.23681 = __builtin_expect (D.23680, 0);
      if (D.23681 != 0) goto <D.23682>; else goto <D.23683>;
      <D.23682>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 697, "rank == pcount");
      <D.23683>:
      D.23677 = cm->klass;
      D.23684 = D.23677->byval_arg.type;
      if (D.23684 == 20) goto <D.23685>; else goto <D.23686>;
      <D.23685>:
      rank.8 = (unsigned int) rank;
      D.23688 = rank.8 * 4;
      lower_bounds = __builtin_alloca (D.23688);
      rank.8 = (unsigned int) rank;
      D.23688 = rank.8 * 4;
      memset (lower_bounds, 0, D.23688);
      goto <D.23689>;
      <D.23686>:
      lower_bounds = 0B;
      <D.23689>:
      D.23677 = cm->klass;
      D.23690 = mono_array_new_full (domain, D.23677, &lengths, lower_bounds);
      return D.23690;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_2 (struct MonoMethod * cm, guint32 length1, guint32 length2)
{
  struct MonoMethodSignature * D.23693;
  short unsigned int D.23694;
  struct MonoClass * D.23695;
  unsigned char D.23696;
  _Bool D.23697;
  long int D.23698;
  long int D.23699;
  unsigned char D.23702;
  unsigned int rank.9;
  unsigned int D.23706;
  struct MonoArray * D.23708;
  struct MonoDomain * domain;
  uintptr_t lengths[2];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23693 = mono_method_signature (cm);
      D.23694 = D.23693->param_count;
      pcount = (int) D.23694;
      D.23695 = cm->klass;
      D.23696 = D.23695->rank;
      rank = (int) D.23696;
      lengths[0] = length1;
      lengths[1] = length2;
      D.23697 = rank != pcount;
      D.23698 = (long int) D.23697;
      D.23699 = __builtin_expect (D.23698, 0);
      if (D.23699 != 0) goto <D.23700>; else goto <D.23701>;
      <D.23700>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 726, "rank == pcount");
      <D.23701>:
      D.23695 = cm->klass;
      D.23702 = D.23695->byval_arg.type;
      if (D.23702 == 20) goto <D.23703>; else goto <D.23704>;
      <D.23703>:
      rank.9 = (unsigned int) rank;
      D.23706 = rank.9 * 4;
      lower_bounds = __builtin_alloca (D.23706);
      rank.9 = (unsigned int) rank;
      D.23706 = rank.9 * 4;
      memset (lower_bounds, 0, D.23706);
      goto <D.23707>;
      <D.23704>:
      lower_bounds = 0B;
      <D.23707>:
      D.23695 = cm->klass;
      D.23708 = mono_array_new_full (domain, D.23695, &lengths, lower_bounds);
      return D.23708;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_3 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3)
{
  struct MonoMethodSignature * D.23711;
  short unsigned int D.23712;
  struct MonoClass * D.23713;
  unsigned char D.23714;
  _Bool D.23715;
  long int D.23716;
  long int D.23717;
  unsigned char D.23720;
  unsigned int rank.10;
  unsigned int D.23724;
  struct MonoArray * D.23726;
  struct MonoDomain * domain;
  uintptr_t lengths[3];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23711 = mono_method_signature (cm);
      D.23712 = D.23711->param_count;
      pcount = (int) D.23712;
      D.23713 = cm->klass;
      D.23714 = D.23713->rank;
      rank = (int) D.23714;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      D.23715 = rank != pcount;
      D.23716 = (long int) D.23715;
      D.23717 = __builtin_expect (D.23716, 0);
      if (D.23717 != 0) goto <D.23718>; else goto <D.23719>;
      <D.23718>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 756, "rank == pcount");
      <D.23719>:
      D.23713 = cm->klass;
      D.23720 = D.23713->byval_arg.type;
      if (D.23720 == 20) goto <D.23721>; else goto <D.23722>;
      <D.23721>:
      rank.10 = (unsigned int) rank;
      D.23724 = rank.10 * 4;
      lower_bounds = __builtin_alloca (D.23724);
      rank.10 = (unsigned int) rank;
      D.23724 = rank.10 * 4;
      memset (lower_bounds, 0, D.23724);
      goto <D.23725>;
      <D.23722>:
      lower_bounds = 0B;
      <D.23725>:
      D.23713 = cm->klass;
      D.23726 = mono_array_new_full (domain, D.23713, &lengths, lower_bounds);
      return D.23726;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_4 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
{
  struct MonoMethodSignature * D.23729;
  short unsigned int D.23730;
  struct MonoClass * D.23731;
  unsigned char D.23732;
  _Bool D.23733;
  long int D.23734;
  long int D.23735;
  unsigned char D.23738;
  unsigned int rank.11;
  unsigned int D.23742;
  struct MonoArray * D.23744;
  struct MonoDomain * domain;
  uintptr_t lengths[4];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23729 = mono_method_signature (cm);
      D.23730 = D.23729->param_count;
      pcount = (int) D.23730;
      D.23731 = cm->klass;
      D.23732 = D.23731->rank;
      rank = (int) D.23732;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      lengths[3] = length4;
      D.23733 = rank != pcount;
      D.23734 = (long int) D.23733;
      D.23735 = __builtin_expect (D.23734, 0);
      if (D.23735 != 0) goto <D.23736>; else goto <D.23737>;
      <D.23736>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 787, "rank == pcount");
      <D.23737>:
      D.23731 = cm->klass;
      D.23738 = D.23731->byval_arg.type;
      if (D.23738 == 20) goto <D.23739>; else goto <D.23740>;
      <D.23739>:
      rank.11 = (unsigned int) rank;
      D.23742 = rank.11 * 4;
      lower_bounds = __builtin_alloca (D.23742);
      rank.11 = (unsigned int) rank;
      D.23742 = rank.11 * 4;
      memset (lower_bounds, 0, D.23742);
      goto <D.23743>;
      <D.23740>:
      lower_bounds = 0B;
      <D.23743>:
      D.23731 = cm->klass;
      D.23744 = mono_array_new_full (domain, D.23731, &lengths, lower_bounds);
      return D.23744;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_class_static_field_address (struct MonoDomain * domain, struct MonoClassField * field)
{
  struct MonoClass * D.23747;
  unsigned char D.23748;
  unsigned char D.23749;
  struct GHashTable * D.23754;
  unsigned int addr.12;
  void * D.23758;
  int D.23759;
  sizetype D.23760;
  void * D.23761;
  struct MonoVTable * vtable;
  void * addr;

  D.23747 = field->parent;
  mono_class_init (D.23747);
  D.23747 = field->parent;
  vtable = mono_class_vtable_full (domain, D.23747, 1);
  D.23748 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.23749 = D.23748 & 2;
  if (D.23749 == 0) goto <D.23750>; else goto <D.23751>;
  <D.23750>:
  mono_runtime_class_init (vtable);
  <D.23751>:
  D.23754 = domain->special_static_fields;
  if (D.23754 != 0B) goto <D.23755>; else goto <D.23752>;
  <D.23755>:
  D.23754 = domain->special_static_fields;
  addr = monoeg_g_hash_table_lookup (D.23754, field);
  if (addr != 0B) goto <D.23756>; else goto <D.23752>;
  <D.23756>:
  addr.12 = (unsigned int) addr;
  addr = mono_get_special_static_data (addr.12);
  goto <D.23753>;
  <D.23752>:
  D.23758 = mono_vtable_get_static_field_data (vtable);
  D.23759 = field->offset;
  D.23760 = (sizetype) D.23759;
  addr = D.23758 + D.23760;
  <D.23753>:
  D.23761 = addr;
  return D.23761;
}


mono_ldtoken_wrapper (struct MonoImage * image, int token, struct MonoGenericContext * context)
{
  unsigned int token.13;
  struct MonoClass * handle_class.14;
  void * D.23765;
  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.23765 = res;
      return D.23765;
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


mono_ldtoken_wrapper_generic_shared (struct MonoImage * image, int token, struct MonoMethod * method)
{
  unsigned char D.23768;
  unsigned char D.23769;
  _Bool D.23773;
  long int D.23774;
  long int D.23775;
  void * D.23778;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;

  sig = mono_method_signature (method);
  D.23768 = BIT_FIELD_REF <*sig, 8, 88>;
  D.23769 = D.23768 & 2;
  if (D.23769 != 0) goto <D.23770>; else goto <D.23771>;
  <D.23770>:
  generic_context = mono_method_get_context (method);
  goto <D.23772>;
  <D.23771>:
  {
    struct MonoGenericContainer * generic_container;

    generic_container = mono_method_get_generic_container (method);
    D.23773 = generic_container == 0B;
    D.23774 = (long int) D.23773;
    D.23775 = __builtin_expect (D.23774, 0);
    if (D.23775 != 0) goto <D.23776>; else goto <D.23777>;
    <D.23776>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 848, "generic_container");
    <D.23777>:
    generic_context = &generic_container->context;
  }
  <D.23772>:
  D.23778 = mono_ldtoken_wrapper (image, token, generic_context);
  return D.23778;
}


mono_fconv_u8 (double v)
{
  guint64 D.23780;

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


mono_fconv_u4 (double v)
{
  int D.23784;
  int D.23786;
  guint32 D.23787;

  D.23784 = __isinf (v);
  if (D.23784 != 0) goto <D.23782>; else goto <D.23785>;
  <D.23785>:
  D.23786 = __isnan (v);
  if (D.23786 != 0) goto <D.23782>; else goto <D.23783>;
  <D.23782>:
  D.23787 = 0;
  return D.23787;
  <D.23783>:
  D.23787 = (guint32) v;
  return D.23787;
}


mono_fconv_ovf_i8 (double v)
{
  int D.23791;
  double D.23793;
  double D.23794;
  struct MonoException * D.23795;
  gint64 D.23796;
  gint64 res;

  res = (gint64) v;
  D.23791 = __isnan (v);
  if (D.23791 != 0) goto <D.23789>; else goto <D.23792>;
  <D.23792>:
  D.23793 = trunc (v);
  D.23794 = (double) res;
  if (D.23793 != D.23794) goto <D.23789>; else goto <D.23790>;
  <D.23789>:
  D.23795 = mono_get_exception_overflow ();
  mono_raise_exception (D.23795);
  <D.23790>:
  D.23796 = res;
  return D.23796;
}


mono_fconv_ovf_u8 (double v)
{
  int D.23800;
  double D.23802;
  double D.23803;
  struct MonoException * D.23804;
  guint64 D.23805;
  guint64 res;

  res = (guint64) v;
  D.23800 = __isnan (v);
  if (D.23800 != 0) goto <D.23798>; else goto <D.23801>;
  <D.23801>:
  D.23802 = trunc (v);
  D.23803 = (double) res;
  if (D.23802 != D.23803) goto <D.23798>; else goto <D.23799>;
  <D.23798>:
  D.23804 = mono_get_exception_overflow ();
  mono_raise_exception (D.23804);
  <D.23799>:
  D.23805 = res;
  return D.23805;
}


mono_helper_compile_generic_method (struct MonoObject * obj, struct MonoMethod * method, void * * this_arg)
{
  int D.23807;
  int D.23808;
  struct MonoException * D.23811;
  struct MonoClass * D.23812;
  struct MonoGenericContainer * D.23813;
  _Bool D.23814;
  long int D.23815;
  long int D.23816;
  int iftmp.15;
  struct MonoGenericClass * D.23822;
  struct MonoGenericInst * D.23824;
  unsigned char D.23825;
  unsigned char D.23826;
  _Bool D.23828;
  long int D.23829;
  long int D.23830;
  int iftmp.16;
  struct MonoGenericInst * D.23836;
  unsigned char D.23838;
  unsigned char D.23839;
  _Bool D.23841;
  long int D.23842;
  long int D.23843;
  int D.23846;
  struct MonoVTable * D.23847;
  struct MonoClass * D.23848;
  unsigned char D.23849;
  unsigned char D.23850;
  void * D.23853;
  void * D.23855;
  struct MonoMethod * vmethod;
  void * addr;
  struct MonoGenericContext * context;

  context = mono_method_get_context (method);
  D.23807 = mono_jit_stats.generic_virtual_invocations;
  D.23808 = D.23807 + 1;
  mono_jit_stats.generic_virtual_invocations = D.23808;
  if (obj == 0B) goto <D.23809>; else goto <D.23810>;
  <D.23809>:
  D.23811 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23811);
  <D.23810>:
  vmethod = mono_object_get_virtual_method (obj, method);
  D.23812 = vmethod->klass;
  D.23813 = D.23812->generic_container;
  D.23814 = D.23813 != 0B;
  D.23815 = (long int) D.23814;
  D.23816 = __builtin_expect (D.23815, 0);
  if (D.23816 != 0) goto <D.23817>; else goto <D.23818>;
  <D.23817>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 993, "!vmethod->klass->generic_container");
  <D.23818>:
  D.23812 = vmethod->klass;
  D.23822 = D.23812->generic_class;
  if (D.23822 != 0B) goto <D.23823>; else goto <D.23820>;
  <D.23823>:
  D.23812 = vmethod->klass;
  D.23822 = D.23812->generic_class;
  D.23824 = D.23822->context.class_inst;
  D.23825 = BIT_FIELD_REF <*D.23824, 8, 48>;
  D.23826 = D.23825 & 64;
  if (D.23826 != 0) goto <D.23827>; else goto <D.23820>;
  <D.23827>:
  iftmp.15 = 1;
  goto <D.23821>;
  <D.23820>:
  iftmp.15 = 0;
  <D.23821>:
  D.23828 = iftmp.15 != 0;
  D.23829 = (long int) D.23828;
  D.23830 = __builtin_expect (D.23829, 0);
  if (D.23830 != 0) goto <D.23831>; else goto <D.23832>;
  <D.23831>:
  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.23832>:
  D.23836 = context->method_inst;
  if (D.23836 != 0B) goto <D.23837>; else goto <D.23834>;
  <D.23837>:
  D.23836 = context->method_inst;
  D.23838 = BIT_FIELD_REF <*D.23836, 8, 48>;
  D.23839 = D.23838 & 64;
  if (D.23839 != 0) goto <D.23840>; else goto <D.23834>;
  <D.23840>:
  iftmp.16 = 1;
  goto <D.23835>;
  <D.23834>:
  iftmp.16 = 0;
  <D.23835>:
  D.23841 = iftmp.16 != 0;
  D.23842 = (long int) D.23841;
  D.23843 = __builtin_expect (D.23842, 0);
  if (D.23843 != 0) goto <D.23844>; else goto <D.23845>;
  <D.23844>:
  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.23845>:
  addr = mono_compile_method (vmethod);
  D.23846 = mono_method_needs_static_rgctx_invoke (vmethod, 0);
  addr = mini_add_method_trampoline (0B, vmethod, addr, D.23846, 0);
  D.23847 = obj->vtable;
  D.23848 = D.23847->klass;
  D.23849 = BIT_FIELD_REF <*D.23848, 8, 160>;
  D.23850 = D.23849 & 8;
  if (D.23850 != 0) goto <D.23851>; else goto <D.23852>;
  <D.23851>:
  D.23853 = mono_object_unbox (obj);
  *this_arg = D.23853;
  goto <D.23854>;
  <D.23852>:
  *this_arg = obj;
  <D.23854>:
  D.23855 = addr;
  return D.23855;
}


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

  D.23858 = mono_domain_get ();
  D.23857 = mono_ldstr (D.23858, image, idx);
  return D.23857;
}


mono_helper_ldstr_mscorlib (guint32 idx)
{
  struct MonoString * D.23860;
  struct MonoImage * D.23861;
  struct MonoDomain * D.23862;

  D.23861 = mono_defaults.corlib;
  D.23862 = mono_domain_get ();
  D.23860 = mono_ldstr (D.23862, D.23861, idx);
  return D.23860;
}


mono_helper_newobj_mscorlib (guint32 idx)
{
  unsigned int D.23864;
  struct MonoImage * D.23865;
  _Bool D.23866;
  long int D.23867;
  long int D.23868;
  struct MonoObject * D.23871;
  struct MonoDomain * D.23872;
  struct MonoClass * klass;

  D.23864 = idx | 33554432;
  D.23865 = mono_defaults.corlib;
  klass = mono_class_get (D.23865, D.23864);
  D.23866 = klass == 0B;
  D.23867 = (long int) D.23866;
  D.23868 = __builtin_expect (D.23867, 0);
  if (D.23868 != 0) goto <D.23869>; else goto <D.23870>;
  <D.23869>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1027, "klass");
  <D.23870>:
  D.23872 = mono_domain_get ();
  D.23871 = mono_object_new (D.23872, klass);
  return D.23871;
}


mono_break ()
{

}


mono_create_corlib_exception_0 (guint32 token)
{
  struct MonoException * D.23874;
  struct MonoImage * D.23875;

  D.23875 = mono_defaults.corlib;
  D.23874 = mono_exception_from_token (D.23875, token);
  return D.23874;
}


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

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


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

  D.23881 = mono_defaults.corlib;
  D.23880 = mono_exception_from_token_two_strings (D.23881, token, arg1, arg2);
  return D.23880;
}


mono_object_castclass_unbox (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoDebugOptions * D.23883;
  int D.23884;
  unsigned int mono_jit_tls_id.17;
  struct MonoObject * D.23890;
  unsigned char D.23891;
  unsigned char D.23892;
  struct MonoVTable * D.23895;
  struct MonoClass * D.23896;
  struct MonoClass * D.23897;
  struct MonoObject * D.23900;
  struct MonoDebugOptions * D.23903;
  int D.23904;
  struct MonoImage * D.23907;
  struct MonoException * D.23908;
  struct MonoJitTlsData * jit_tls;

  jit_tls = 0B;
  D.23883 = mini_get_debug_options ();
  D.23884 = D.23883->better_cast_details;
  if (D.23884 != 0) goto <D.23885>; else goto <D.23886>;
  <D.23885>:
  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.23886>:
  if (obj == 0B) goto <D.23888>; else goto <D.23889>;
  <D.23888>:
  D.23890 = 0B;
  return D.23890;
  <D.23889>:
  D.23891 = BIT_FIELD_REF <*klass, 8, 160>;
  D.23892 = D.23891 & 16;
  if (D.23892 != 0) goto <D.23893>; else goto <D.23894>;
  <D.23893>:
  D.23895 = obj->vtable;
  D.23896 = D.23895->klass;
  D.23897 = klass->element_class;
  if (D.23896 == D.23897) goto <D.23898>; else goto <D.23899>;
  <D.23898>:
  D.23890 = obj;
  return D.23890;
  <D.23899>:
  <D.23894>:
  D.23900 = mono_object_isinst (obj, klass);
  if (D.23900 != 0B) goto <D.23901>; else goto <D.23902>;
  <D.23901>:
  D.23890 = obj;
  return D.23890;
  <D.23902>:
  D.23903 = mini_get_debug_options ();
  D.23904 = D.23903->better_cast_details;
  if (D.23904 != 0) goto <D.23905>; else goto <D.23906>;
  <D.23905>:
  D.23895 = obj->vtable;
  D.23896 = D.23895->klass;
  jit_tls->class_cast_from = D.23896;
  jit_tls->class_cast_to = klass;
  <D.23906>:
  D.23907 = mono_defaults.corlib;
  D.23908 = mono_exception_from_name (D.23907, "System", "InvalidCastException");
  mono_raise_exception (D.23908);
  D.23890 = 0B;
  return D.23890;
}


mono_object_castclass_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoDebugOptions * D.23910;
  int D.23911;
  unsigned int mono_jit_tls_id.18;
  struct MonoObject * D.23917;
  struct MonoObject * D.23920;
  struct MonoDebugOptions * D.23923;
  int D.23924;
  struct MonoVTable * D.23927;
  struct MonoClass * D.23928;
  struct MonoImage * D.23929;
  struct MonoException * D.23930;
  struct MonoJitTlsData * jit_tls;
  void * cached_vtable;
  void * obj_vtable;

  jit_tls = 0B;
  D.23910 = mini_get_debug_options ();
  D.23911 = D.23910->better_cast_details;
  if (D.23911 != 0) goto <D.23912>; else goto <D.23913>;
  <D.23912>:
  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.23913>:
  if (obj == 0B) goto <D.23915>; else goto <D.23916>;
  <D.23915>:
  D.23917 = 0B;
  return D.23917;
  <D.23916>:
  cached_vtable = *cache;
  obj_vtable = obj->vtable;
  if (cached_vtable == obj_vtable) goto <D.23918>; else goto <D.23919>;
  <D.23918>:
  D.23917 = obj;
  return D.23917;
  <D.23919>:
  D.23920 = mono_object_isinst (obj, klass);
  if (D.23920 != 0B) goto <D.23921>; else goto <D.23922>;
  <D.23921>:
  *cache = obj_vtable;
  D.23917 = obj;
  return D.23917;
  <D.23922>:
  D.23923 = mini_get_debug_options ();
  D.23924 = D.23923->better_cast_details;
  if (D.23924 != 0) goto <D.23925>; else goto <D.23926>;
  <D.23925>:
  D.23927 = obj->vtable;
  D.23928 = D.23927->klass;
  jit_tls->class_cast_from = D.23928;
  jit_tls->class_cast_to = klass;
  <D.23926>:
  D.23929 = mono_defaults.corlib;
  D.23930 = mono_exception_from_name (D.23929, "System", "InvalidCastException");
  mono_raise_exception (D.23930);
  D.23917 = 0B;
  return D.23917;
}


mono_object_isinst_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoObject * D.23934;
  void * D.23935;
  struct MonoVTable * D.23936;
  unsigned int D.23937;
  struct MonoObject * iftmp.19;
  unsigned int D.23941;
  struct MonoObject * D.23945;
  void * obj_vtable.20;
  unsigned int D.23949;
  void * D.23950;
  size_t cached_vtable;
  size_t obj_vtable;

  if (obj == 0B) goto <D.23932>; else goto <D.23933>;
  <D.23932>:
  D.23934 = 0B;
  return D.23934;
  <D.23933>:
  D.23935 = *cache;
  cached_vtable = (size_t) D.23935;
  D.23936 = obj->vtable;
  obj_vtable = (size_t) D.23936;
  D.23937 = cached_vtable & 4294967294;
  if (D.23937 == obj_vtable) goto <D.23938>; else goto <D.23939>;
  <D.23938>:
  D.23941 = cached_vtable & 1;
  if (D.23941 == 0) goto <D.23942>; else goto <D.23943>;
  <D.23942>:
  iftmp.19 = obj;
  goto <D.23944>;
  <D.23943>:
  iftmp.19 = 0B;
  <D.23944>:
  D.23934 = iftmp.19;
  return D.23934;
  <D.23939>:
  D.23945 = mono_object_isinst (obj, klass);
  if (D.23945 != 0B) goto <D.23946>; else goto <D.23947>;
  <D.23946>:
  obj_vtable.20 = (void *) obj_vtable;
  *cache = obj_vtable.20;
  D.23934 = obj;
  return D.23934;
  <D.23947>:
  D.23949 = obj_vtable | 1;
  D.23950 = (void *) D.23949;
  *cache = D.23950;
  D.23934 = 0B;
  return D.23934;
}


mono_get_native_calli_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, void * func)
{
  short unsigned int D.23952;
  int D.23953;
  int D.23954;
  unsigned int D.23955;
  unsigned int D.23956;
  void * D.23957;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct MonoMethod * m;

  try
    {
      D.23952 = sig->param_count;
      D.23953 = (int) D.23952;
      D.23954 = D.23953 + 1;
      D.23955 = (unsigned int) D.23954;
      D.23956 = D.23955 * 4;
      mspecs = monoeg_malloc0 (D.23956);
      memset (&piinfo, 0, 32);
      m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
      D.23957 = mono_compile_method (m);
      return D.23957;
    }
  finally
    {
      piinfo = {CLOBBER};
    }
}


mono_gsharedvt_constrained_call (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, gboolean deref_arg, void * * args)
{
  _Bool D.23960;
  _Bool D.23961;
  _Bool D.23962;
  void * D.23965;
  void * D.23966;
  unsigned char D.23967;
  unsigned char D.23968;
  void * this_arg.21;
  struct MonoObject * D.23972;
  struct MonoMethod * m;
  void * this_arg;
  void * new_args[16];

  try
    {
      m = constrained_gsharedvt_call_setup (mp, cmethod, klass, &this_arg);
      D.23960 = args != 0B;
      D.23961 = deref_arg != 0;
      D.23962 = D.23960 & D.23961;
      if (D.23962 != 0) goto <D.23963>; else goto <D.23964>;
      <D.23963>:
      D.23965 = *args;
      D.23966 = MEM[(void * *)D.23965];
      new_args[0] = D.23966;
      args = &new_args;
      <D.23964>:
      D.23967 = BIT_FIELD_REF <*m, 8, 160>;
      D.23968 = D.23967 & 124;
      if (D.23968 == 24) goto <D.23969>; else goto <D.23970>;
      <D.23969>:
      args = &new_args;
      this_arg.21 = this_arg;
      *args = this_arg.21;
      this_arg = 0B;
      <D.23970>:
      this_arg.21 = this_arg;
      D.23972 = mono_runtime_invoke (m, this_arg.21, args, 0B);
      return D.23972;
    }
  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.23975;
  unsigned int D.23976;
  struct MonoException * D.23979;
  struct MonoMethodSignature * D.23980;
  unsigned char D.23981;
  unsigned char D.23982;
  struct MonoMethod * * D.23986;
  _Bool D.23987;
  long int D.23988;
  long int D.23989;
  struct MonoClass * D.23992;
  unsigned int D.23993;
  unsigned int D.23994;
  _Bool D.23997;
  long int D.23998;
  long int D.23999;
  unsigned int vt_slot.22;
  unsigned int D.24003;
  struct MonoMethod * * D.24004;
  unsigned char D.24008;
  unsigned char D.24009;
  struct MonoClass * D.24011;
  struct MonoClass * D.24012;
  struct MonoClass * D.24014;
  struct MonoClass * D.24015;
  struct MonoDomain * D.24017;
  struct MonoObject * D.24018;
  void * D.24022;
  struct MonoMethod * D.24023;
  struct MonoMethod * m;
  int vt_slot;

  D.23975 = klass->flags;
  D.23976 = D.23975 & 32;
  if (D.23976 != 0) goto <D.23977>; else goto <D.23978>;
  <D.23977>:
  D.23979 = mono_get_exception_execution_engine ("Not yet supported.");
  mono_raise_exception (D.23979);
  <D.23978>:
  D.23980 = mono_method_signature (cmethod);
  D.23981 = BIT_FIELD_REF <*D.23980, 8, 88>;
  D.23982 = D.23981 & 1;
  if (D.23982 != 0) goto <D.23983>; else goto <D.23984>;
  <D.23983>:
  m = mono_marshal_get_native_wrapper (cmethod, 1, 0);
  goto <D.23985>;
  <D.23984>:
  mono_class_setup_vtable (klass);
  D.23986 = klass->vtable;
  D.23987 = D.23986 == 0B;
  D.23988 = (long int) D.23987;
  D.23989 = __builtin_expect (D.23988, 0);
  if (D.23989 != 0) goto <D.23990>; else goto <D.23991>;
  <D.23990>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1180, "klass->vtable");
  <D.23991>:
  vt_slot = mono_method_get_vtable_slot (cmethod);
  D.23992 = cmethod->klass;
  D.23993 = D.23992->flags;
  D.23994 = D.23993 & 32;
  if (D.23994 != 0) goto <D.23995>; else goto <D.23996>;
  <D.23995>:
  {
    int iface_offset;

    D.23992 = cmethod->klass;
    iface_offset = mono_class_interface_offset (klass, D.23992);
    D.23997 = iface_offset == -1;
    D.23998 = (long int) D.23997;
    D.23999 = __builtin_expect (D.23998, 0);
    if (D.23999 != 0) goto <D.24000>; else goto <D.24001>;
    <D.24000>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1186, "iface_offset != -1");
    <D.24001>:
    vt_slot = vt_slot + iface_offset;
  }
  <D.23996>:
  D.23986 = klass->vtable;
  vt_slot.22 = (unsigned int) vt_slot;
  D.24003 = vt_slot.22 * 4;
  D.24004 = D.23986 + D.24003;
  m = *D.24004;
  <D.23985>:
  D.24008 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24009 = D.24008 & 8;
  if (D.24009 != 0) goto <D.24010>; else goto <D.24005>;
  <D.24010>:
  D.24011 = m->klass;
  D.24012 = mono_defaults.object_class;
  if (D.24011 == D.24012) goto <D.24006>; else goto <D.24013>;
  <D.24013>:
  D.24011 = m->klass;
  D.24014 = mono_defaults.enum_class;
  D.24015 = D.24014->parent;
  if (D.24011 == D.24015) goto <D.24006>; else goto <D.24016>;
  <D.24016>:
  D.24011 = m->klass;
  D.24014 = mono_defaults.enum_class;
  if (D.24011 == D.24014) goto <D.24006>; else goto <D.24005>;
  <D.24006>:
  D.24017 = mono_domain_get ();
  D.24018 = mono_value_box (D.24017, klass, mp);
  *this_arg = D.24018;
  goto <D.24007>;
  <D.24005>:
  D.24008 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24009 = D.24008 & 8;
  if (D.24009 != 0) goto <D.24019>; else goto <D.24020>;
  <D.24019>:
  *this_arg = mp;
  goto <D.24021>;
  <D.24020>:
  D.24022 = MEM[(void * *)mp];
  *this_arg = D.24022;
  <D.24021>:
  <D.24007>:
  D.24023 = m;
  return D.24023;
}


mono_gsharedvt_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  unsigned char D.24025;
  unsigned char D.24026;
  struct MonoObject * D.24030;

  D.24025 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24026 = D.24025 & 8;
  if (D.24026 != 0) goto <D.24027>; else goto <D.24028>;
  <D.24027>:
  mono_value_copy (dest, src, klass);
  goto <D.24029>;
  <D.24028>:
  D.24030 = MEM[(struct MonoObject * *)src];
  mono_gc_wbarrier_generic_store (dest, D.24030);
  <D.24029>:
}