mono_ldftn (struct MonoMethod * method)
{
  struct MonoDomain * D.26184;
  void * D.26185;
  struct MonoDomain * D.26186;
  void * addr;

  D.26184 = mono_domain_get ();
  addr = mono_create_jump_trampoline (D.26184, method, 0);
  D.26186 = mono_domain_get ();
  D.26185 = mono_create_ftnptr (D.26186, addr);
  return D.26185;
}


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

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


ldvirtfn_internal (struct MonoObject * obj, struct MonoMethod * method, gboolean gshared)
{
  struct MonoException * D.26192;
  unsigned char D.26195;
  unsigned char D.26196;
  struct MonoGenericContext * D.26199;
  struct MonoGenericInst * D.26200;
  struct MonoClass * D.26203;
  struct MonoGenericClass * D.26204;
  struct MonoGenericInst * D.26207;
  struct MonoGenericContainer * D.26209;
  struct MonoGenericInst * D.26212;
  struct MonoGenericContext * D.26213;
  struct MonoGenericInst * D.26214;
  void * D.26215;
  struct MonoMethod * res;

  if (obj == 0B) goto <D.26190>; else goto <D.26191>;
  <D.26190>:
  D.26192 = mono_get_exception_null_reference ();
  mono_raise_exception (D.26192);
  <D.26191>:
  res = mono_object_get_virtual_method (obj, method);
  if (gshared != 0) goto <D.26193>; else goto <D.26194>;
  <D.26193>:
  D.26195 = BIT_FIELD_REF <*method, 8, 168>;
  D.26196 = D.26195 & 16;
  if (D.26196 != 0) goto <D.26197>; else goto <D.26198>;
  <D.26197>:
  D.26199 = mono_method_get_context (method);
  D.26200 = D.26199->method_inst;
  if (D.26200 != 0B) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  {
    struct MonoGenericContext context;

    try
      {
        context.class_inst = 0B;
        context.method_inst = 0B;
        D.26203 = res->klass;
        D.26204 = D.26203->generic_class;
        if (D.26204 != 0B) goto <D.26205>; else goto <D.26206>;
        <D.26205>:
        D.26203 = res->klass;
        D.26204 = D.26203->generic_class;
        D.26207 = D.26204->context.class_inst;
        context.class_inst = D.26207;
        goto <D.26208>;
        <D.26206>:
        D.26203 = res->klass;
        D.26209 = D.26203->generic_container;
        if (D.26209 != 0B) goto <D.26210>; else goto <D.26211>;
        <D.26210>:
        D.26203 = res->klass;
        D.26209 = D.26203->generic_container;
        D.26212 = D.26209->context.class_inst;
        context.class_inst = D.26212;
        <D.26211>:
        <D.26208>:
        D.26213 = mono_method_get_context (method);
        D.26214 = D.26213->method_inst;
        context.method_inst = D.26214;
        res = mono_class_inflate_generic_method (res, &context);
      }
    finally
      {
        context = {CLOBBER};
      }
  }
  <D.26202>:
  <D.26198>:
  <D.26194>:
  D.26215 = mono_ldftn (res);
  return D.26215;
}


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

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


mono_helper_stelem_ref_check (struct MonoArray * array, struct MonoObject * val)
{
  struct MonoException * D.26221;
  struct MonoVTable * D.26224;
  struct MonoClass * D.26225;
  struct MonoClass * D.26226;
  struct MonoObject * D.26227;
  struct MonoException * D.26230;

  if (array == 0B) goto <D.26219>; else goto <D.26220>;
  <D.26219>:
  D.26221 = mono_get_exception_null_reference ();
  mono_raise_exception (D.26221);
  <D.26220>:
  if (val != 0B) goto <D.26222>; else goto <D.26223>;
  <D.26222>:
  D.26224 = array->obj.vtable;
  D.26225 = D.26224->klass;
  D.26226 = D.26225->element_class;
  D.26227 = mono_object_isinst (val, D.26226);
  if (D.26227 == 0B) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  D.26230 = mono_get_exception_array_type_mismatch ();
  mono_raise_exception (D.26230);
  <D.26229>:
  <D.26223>:
}


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

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


mono_llmult_ovf_un (guint64 a, guint64 b)
{
  long long unsigned int D.26233;
  long long unsigned int D.26234;
  _Bool D.26235;
  _Bool D.26236;
  _Bool D.26237;
  long long unsigned int D.26239;
  long long unsigned int D.26240;
  long long unsigned int D.26241;
  long long unsigned int D.26242;
  long long unsigned int D.26243;
  long long unsigned int D.26244;
  long long unsigned int D.26246;
  guint64 D.26247;
  struct MonoException * D.26248;
  guint32 al;
  guint32 ah;
  guint32 bl;
  guint32 bh;
  guint64 res;
  guint64 t1;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.26233 = a >> 32;
  ah = (guint32) D.26233;
  bl = (guint32) b;
  D.26234 = b >> 32;
  bh = (guint32) D.26234;
  D.26235 = ah != 0;
  D.26236 = bh != 0;
  D.26237 = D.26235 & D.26236;
  if (D.26237 != 0) goto raise_exception; else goto <D.26238>;
  <D.26238>:
  D.26239 = (long long unsigned int) al;
  D.26240 = (long long unsigned int) bl;
  res = D.26239 * D.26240;
  D.26241 = (long long unsigned int) ah;
  D.26240 = (long long unsigned int) bl;
  D.26242 = D.26241 * D.26240;
  D.26239 = (long long unsigned int) al;
  D.26243 = (long long unsigned int) bh;
  D.26244 = D.26239 * D.26243;
  t1 = D.26242 + D.26244;
  if (t1 > 4294967295) goto raise_exception; else goto <D.26245>;
  <D.26245>:
  D.26246 = t1 << 32;
  res = D.26246 + res;
  D.26247 = res;
  return D.26247;
  raise_exception:
  D.26248 = mono_get_exception_overflow ();
  mono_raise_exception (D.26248);
  D.26247 = 0;
  return D.26247;
}


mono_llmult_ovf (gint64 a, gint64 b)
{
  long long int D.26250;
  long long int D.26251;
  _Bool D.26254;
  _Bool D.26255;
  _Bool D.26256;
  guint64 D.26261;
  _Bool D.26268;
  _Bool D.26269;
  _Bool D.26270;
  _Bool D.26279;
  _Bool D.26280;
  _Bool D.26281;
  long long int D.26283;
  long long int D.26284;
  long long int D.26285;
  long long int D.26287;
  long long int D.26288;
  long long int D.26289;
  unsigned int ah.0;
  unsigned int D.26292;
  long long int D.26293;
  unsigned int bh.1;
  unsigned int D.26295;
  long long int D.26296;
  long long int D.26297;
  long long int D.26298;
  long long int D.26303;
  struct MonoException * D.26304;
  guint32 al;
  gint32 ah;
  guint32 bl;
  gint32 bh;
  gint64 res;
  gint64 t1;
  gint32 sign;
  void raise_exception = <<< error >>>;

  al = (guint32) a;
  D.26250 = a >> 32;
  ah = (gint32) D.26250;
  bl = (guint32) b;
  D.26251 = b >> 32;
  bh = (gint32) D.26251;
  sign = ah ^ bh;
  if (ah < 0) goto <D.26252>; else goto <D.26253>;
  <D.26252>:
  D.26254 = ah == -2147483648;
  D.26255 = al == 0;
  D.26256 = D.26254 & D.26255;
  if (D.26256 != 0) goto <D.26257>; else goto <D.26258>;
  <D.26257>:
  if (b == 0) goto <D.26259>; else goto <D.26260>;
  <D.26259>:
  D.26261 = 0;
  return D.26261;
  <D.26260>:
  if (b == 1) goto <D.26262>; else goto raise_exception;
  <D.26262>:
  D.26261 = (guint64) a;
  return D.26261;
  <D.26258>:
  ah = ~ah;
  if (al == 0) goto <D.26263>; else goto <D.26264>;
  <D.26263>:
  ah = ah + 1;
  goto <D.26265>;
  <D.26264>:
  al = ~al;
  al = al + 1;
  <D.26265>:
  <D.26253>:
  if (bh < 0) goto <D.26266>; else goto <D.26267>;
  <D.26266>:
  D.26268 = bh == -2147483648;
  D.26269 = bl == 0;
  D.26270 = D.26268 & D.26269;
  if (D.26270 != 0) goto <D.26271>; else goto <D.26272>;
  <D.26271>:
  if (a == 0) goto <D.26273>; else goto <D.26274>;
  <D.26273>:
  D.26261 = 0;
  return D.26261;
  <D.26274>:
  if (a == 1) goto <D.26275>; else goto raise_exception;
  <D.26275>:
  D.26261 = (guint64) b;
  return D.26261;
  <D.26272>:
  bh = ~bh;
  if (bl == 0) goto <D.26276>; else goto <D.26277>;
  <D.26276>:
  bh = bh + 1;
  goto <D.26278>;
  <D.26277>:
  bl = ~bl;
  bl = bl + 1;
  <D.26278>:
  <D.26267>:
  D.26279 = ah != 0;
  D.26280 = bh != 0;
  D.26281 = D.26279 & D.26280;
  if (D.26281 != 0) goto raise_exception; else goto <D.26282>;
  <D.26282>:
  D.26283 = (long long int) ah;
  D.26284 = (long long int) bl;
  D.26285 = D.26283 * D.26284;
  if (D.26285 > 2147483648) goto raise_exception; else goto <D.26286>;
  <D.26286>:
  D.26287 = (long long int) al;
  D.26288 = (long long int) bh;
  D.26289 = D.26287 * D.26288;
  if (D.26289 > 2147483648) goto raise_exception; else goto <D.26290>;
  <D.26290>:
  D.26287 = (long long int) al;
  D.26284 = (long long int) bl;
  t1 = D.26287 * D.26284;
  res = t1;
  ah.0 = (unsigned int) ah;
  D.26292 = ah.0 - al;
  D.26293 = (long long int) D.26292;
  bh.1 = (unsigned int) bh;
  D.26295 = bl - bh.1;
  D.26296 = (long long int) D.26295;
  D.26297 = D.26293 * D.26296;
  t1 = D.26297 + t1;
  t1 = t1 << 32;
  D.26298 = 9223372036854775807 - res;
  if (D.26298 < t1) goto raise_exception; else goto <D.26299>;
  <D.26299>:
  res = res + t1;
  if (res < 0) goto raise_exception; else goto <D.26300>;
  <D.26300>:
  if (sign < 0) goto <D.26301>; else goto <D.26302>;
  <D.26301>:
  D.26303 = -res;
  D.26261 = (guint64) D.26303;
  return D.26261;
  <D.26302>:
  D.26261 = (guint64) res;
  return D.26261;
  raise_exception:
  D.26304 = mono_get_exception_overflow ();
  mono_raise_exception (D.26304);
  D.26261 = 0;
  return D.26261;
}


mono_lldiv (gint64 a, gint64 b)
{
  struct MonoException * D.26308;
  _Bool D.26310;
  _Bool D.26311;
  _Bool D.26312;
  struct MonoException * D.26315;
  gint64 D.26316;

  if (b == 0) goto <D.26306>; else goto <D.26307>;
  <D.26306>:
  D.26308 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26308);
  goto <D.26309>;
  <D.26307>:
  D.26310 = b == -1;
  D.26311 = a == -9223372036854775808;
  D.26312 = D.26310 & D.26311;
  if (D.26312 != 0) goto <D.26313>; else goto <D.26314>;
  <D.26313>:
  D.26315 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.26315);
  <D.26314>:
  <D.26309>:
  D.26316 = a / b;
  return D.26316;
}


mono_llrem (gint64 a, gint64 b)
{
  struct MonoException * D.26320;
  _Bool D.26322;
  _Bool D.26323;
  _Bool D.26324;
  struct MonoException * D.26327;
  gint64 D.26328;

  if (b == 0) goto <D.26318>; else goto <D.26319>;
  <D.26318>:
  D.26320 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26320);
  goto <D.26321>;
  <D.26319>:
  D.26322 = b == -1;
  D.26323 = a == -9223372036854775808;
  D.26324 = D.26322 & D.26323;
  if (D.26324 != 0) goto <D.26325>; else goto <D.26326>;
  <D.26325>:
  D.26327 = mono_get_exception_arithmetic ();
  mono_raise_exception (D.26327);
  <D.26326>:
  <D.26321>:
  D.26328 = a % b;
  return D.26328;
}


mono_lldiv_un (guint64 a, guint64 b)
{
  struct MonoException * D.26332;
  guint64 D.26333;

  if (b == 0) goto <D.26330>; else goto <D.26331>;
  <D.26330>:
  D.26332 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26332);
  <D.26331>:
  D.26333 = a / b;
  return D.26333;
}


mono_llrem_un (guint64 a, guint64 b)
{
  struct MonoException * D.26337;
  guint64 D.26338;

  if (b == 0) goto <D.26335>; else goto <D.26336>;
  <D.26335>:
  D.26337 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26337);
  <D.26336>:
  D.26338 = a % b;
  return D.26338;
}


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

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


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

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


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

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


mono_idiv (gint32 a, gint32 b)
{
  struct MonoException * D.26348;
  _Bool D.26350;
  _Bool D.26351;
  _Bool D.26352;
  struct MonoException * D.26355;
  gint32 D.26356;

  if (b == 0) goto <D.26346>; else goto <D.26347>;
  <D.26346>:
  D.26348 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26348);
  goto <D.26349>;
  <D.26347>:
  D.26350 = b == -1;
  D.26351 = a == -2147483648;
  D.26352 = D.26350 & D.26351;
  if (D.26352 != 0) goto <D.26353>; else goto <D.26354>;
  <D.26353>:
  D.26355 = mono_get_exception_overflow ();
  mono_raise_exception (D.26355);
  <D.26354>:
  <D.26349>:
  D.26356 = a / b;
  return D.26356;
}


mono_idiv_un (guint32 a, guint32 b)
{
  struct MonoException * D.26360;
  guint32 D.26361;

  if (b == 0) goto <D.26358>; else goto <D.26359>;
  <D.26358>:
  D.26360 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26360);
  <D.26359>:
  D.26361 = a / b;
  return D.26361;
}


mono_irem (gint32 a, gint32 b)
{
  struct MonoException * D.26365;
  _Bool D.26367;
  _Bool D.26368;
  _Bool D.26369;
  struct MonoException * D.26372;
  gint32 D.26373;

  if (b == 0) goto <D.26363>; else goto <D.26364>;
  <D.26363>:
  D.26365 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26365);
  goto <D.26366>;
  <D.26364>:
  D.26367 = b == -1;
  D.26368 = a == -2147483648;
  D.26369 = D.26367 & D.26368;
  if (D.26369 != 0) goto <D.26370>; else goto <D.26371>;
  <D.26370>:
  D.26372 = mono_get_exception_overflow ();
  mono_raise_exception (D.26372);
  <D.26371>:
  <D.26366>:
  D.26373 = a % b;
  return D.26373;
}


mono_irem_un (guint32 a, guint32 b)
{
  struct MonoException * D.26377;
  guint32 D.26378;

  if (b == 0) goto <D.26375>; else goto <D.26376>;
  <D.26375>:
  D.26377 = mono_get_exception_divide_by_zero ();
  mono_raise_exception (D.26377);
  <D.26376>:
  D.26378 = a % b;
  return D.26378;
}


mono_imul (gint32 a, gint32 b)
{
  gint32 D.26380;

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


mono_imul_ovf (gint32 a, gint32 b)
{
  long long int D.26382;
  long long int D.26383;
  unsigned long long res.2;
  unsigned long long D.26385;
  struct MonoException * D.26388;
  gint32 D.26389;
  gint64 res;

  D.26382 = (long long int) a;
  D.26383 = (long long int) b;
  res = D.26382 * D.26383;
  res.2 = (unsigned long long) res;
  D.26385 = res.2 + 2147483648;
  if (D.26385 > 4294967295) goto <D.26386>; else goto <D.26387>;
  <D.26386>:
  D.26388 = mono_get_exception_overflow ();
  mono_raise_exception (D.26388);
  <D.26387>:
  D.26389 = (gint32) res;
  return D.26389;
}


mono_imul_ovf_un (guint32 a, guint32 b)
{
  long long unsigned int D.26391;
  long long unsigned int D.26392;
  long long unsigned int D.26393;
  struct MonoException * D.26396;
  gint32 D.26397;
  guint64 res;

  D.26391 = (long long unsigned int) a;
  D.26392 = (long long unsigned int) b;
  res = D.26391 * D.26392;
  D.26393 = res >> 32;
  if (D.26393 != 0) goto <D.26394>; else goto <D.26395>;
  <D.26394>:
  D.26396 = mono_get_exception_overflow ();
  mono_raise_exception (D.26396);
  <D.26395>:
  D.26397 = (gint32) res;
  return D.26397;
}


mono_array_new_va (struct MonoMethod * cm)
{
  struct MonoMethodSignature * D.26399;
  short unsigned int D.26400;
  struct MonoClass * D.26401;
  unsigned char D.26402;
  unsigned int pcount.3;
  unsigned int D.26404;
  unsigned int i.4;
  unsigned int D.26406;
  uintptr_t * D.26407;
  void * D.26408;
  void * D.26409;
  unsigned int d.5;
  unsigned char D.26413;
  unsigned int rank.6;
  unsigned int D.26417;
  int D.26420;
  _Bool D.26421;
  long int D.26422;
  long int D.26423;
  struct MonoArray * D.26426;
  struct MonoDomain * domain;
  struct va_list ap;
  uintptr_t * lengths;
  intptr_t * lower_bounds;
  int pcount;
  int rank;
  int i;
  int d;

  try
    {
      domain = mono_domain_get ();
      D.26399 = mono_method_signature (cm);
      D.26400 = D.26399->param_count;
      pcount = (int) D.26400;
      D.26401 = cm->klass;
      D.26402 = D.26401->rank;
      rank = (int) D.26402;
      __builtin_va_start (&ap, 0);
      pcount.3 = (unsigned int) pcount;
      D.26404 = pcount.3 * 4;
      lengths = __builtin_alloca (D.26404);
      i = 0;
      goto <D.26001>;
      <D.26000>:
      i.4 = (unsigned int) i;
      D.26406 = i.4 * 4;
      D.26407 = lengths + D.26406;
      D.26408 = ap.__ap;
      D.26409 = D.26408 + 4;
      ap.__ap = D.26409;
      d = MEM[(int *)D.26408];
      d.5 = (unsigned int) d;
      *D.26407 = d.5;
      i = i + 1;
      <D.26001>:
      if (i < pcount) goto <D.26000>; else goto <D.26002>;
      <D.26002>:
      if (rank == pcount) goto <D.26411>; else goto <D.26412>;
      <D.26411>:
      D.26401 = cm->klass;
      D.26413 = D.26401->byval_arg.type;
      if (D.26413 == 20) goto <D.26414>; else goto <D.26415>;
      <D.26414>:
      rank.6 = (unsigned int) rank;
      D.26417 = rank.6 * 4;
      lower_bounds = __builtin_alloca (D.26417);
      rank.6 = (unsigned int) rank;
      D.26417 = rank.6 * 4;
      memset (lower_bounds, 0, D.26417);
      goto <D.26418>;
      <D.26415>:
      lower_bounds = 0B;
      <D.26418>:
      goto <D.26419>;
      <D.26412>:
      D.26420 = rank * 2;
      D.26421 = D.26420 != pcount;
      D.26422 = (long int) D.26421;
      D.26423 = __builtin_expect (D.26422, 0);
      if (D.26423 != 0) goto <D.26424>; else goto <D.26425>;
      <D.26424>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 670, "pcount == (rank * 2)");
      <D.26425>:
      lower_bounds = lengths;
      rank.6 = (unsigned int) rank;
      D.26417 = rank.6 * 4;
      lengths = lengths + D.26417;
      <D.26419>:
      __builtin_va_end (&ap);
      D.26401 = cm->klass;
      D.26426 = mono_array_new_full (domain, D.26401, lengths, lower_bounds);
      return D.26426;
    }
  finally
    {
      ap = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26431;
  int D.26436;
  void * D.26438;
  unsigned int D.26439;

  D.26431 = __builtin_constant_p (__len);
  if (D.26431 != 0) goto <D.26432>; else goto <D.26433>;
  <D.26432>:
  if (__len == 0) goto <D.26434>; else goto <D.26435>;
  <D.26434>:
  D.26436 = __builtin_constant_p (__ch);
  if (D.26436 == 0) goto <D.26429>; else goto <D.26437>;
  <D.26437>:
  if (__ch != 0) goto <D.26429>; else goto <D.26430>;
  <D.26429>:
  __warn_memset_zero_len ();
  D.26438 = __dest;
  return D.26438;
  <D.26430>:
  <D.26435>:
  <D.26433>:
  D.26439 = __builtin_object_size (__dest, 0);
  D.26438 = __builtin___memset_chk (__dest, __ch, __len, D.26439);
  return D.26438;
}


mono_array_new_1 (struct MonoMethod * cm, guint32 length)
{
  struct MonoMethodSignature * D.26441;
  short unsigned int D.26442;
  struct MonoClass * D.26443;
  unsigned char D.26444;
  _Bool D.26445;
  long int D.26446;
  long int D.26447;
  unsigned char D.26450;
  unsigned int rank.7;
  unsigned int D.26454;
  struct MonoArray * D.26456;
  struct MonoDomain * domain;
  uintptr_t lengths[1];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.26441 = mono_method_signature (cm);
      D.26442 = D.26441->param_count;
      pcount = (int) D.26442;
      D.26443 = cm->klass;
      D.26444 = D.26443->rank;
      rank = (int) D.26444;
      lengths[0] = length;
      D.26445 = rank != pcount;
      D.26446 = (long int) D.26445;
      D.26447 = __builtin_expect (D.26446, 0);
      if (D.26447 != 0) goto <D.26448>; else goto <D.26449>;
      <D.26448>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 697, "rank == pcount");
      <D.26449>:
      D.26443 = cm->klass;
      D.26450 = D.26443->byval_arg.type;
      if (D.26450 == 20) goto <D.26451>; else goto <D.26452>;
      <D.26451>:
      rank.7 = (unsigned int) rank;
      D.26454 = rank.7 * 4;
      lower_bounds = __builtin_alloca (D.26454);
      rank.7 = (unsigned int) rank;
      D.26454 = rank.7 * 4;
      memset (lower_bounds, 0, D.26454);
      goto <D.26455>;
      <D.26452>:
      lower_bounds = 0B;
      <D.26455>:
      D.26443 = cm->klass;
      D.26456 = mono_array_new_full (domain, D.26443, &lengths, lower_bounds);
      return D.26456;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_2 (struct MonoMethod * cm, guint32 length1, guint32 length2)
{
  struct MonoMethodSignature * D.26459;
  short unsigned int D.26460;
  struct MonoClass * D.26461;
  unsigned char D.26462;
  _Bool D.26463;
  long int D.26464;
  long int D.26465;
  unsigned char D.26468;
  unsigned int rank.8;
  unsigned int D.26472;
  struct MonoArray * D.26474;
  struct MonoDomain * domain;
  uintptr_t lengths[2];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.26459 = mono_method_signature (cm);
      D.26460 = D.26459->param_count;
      pcount = (int) D.26460;
      D.26461 = cm->klass;
      D.26462 = D.26461->rank;
      rank = (int) D.26462;
      lengths[0] = length1;
      lengths[1] = length2;
      D.26463 = rank != pcount;
      D.26464 = (long int) D.26463;
      D.26465 = __builtin_expect (D.26464, 0);
      if (D.26465 != 0) goto <D.26466>; else goto <D.26467>;
      <D.26466>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 726, "rank == pcount");
      <D.26467>:
      D.26461 = cm->klass;
      D.26468 = D.26461->byval_arg.type;
      if (D.26468 == 20) goto <D.26469>; else goto <D.26470>;
      <D.26469>:
      rank.8 = (unsigned int) rank;
      D.26472 = rank.8 * 4;
      lower_bounds = __builtin_alloca (D.26472);
      rank.8 = (unsigned int) rank;
      D.26472 = rank.8 * 4;
      memset (lower_bounds, 0, D.26472);
      goto <D.26473>;
      <D.26470>:
      lower_bounds = 0B;
      <D.26473>:
      D.26461 = cm->klass;
      D.26474 = mono_array_new_full (domain, D.26461, &lengths, lower_bounds);
      return D.26474;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_3 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3)
{
  struct MonoMethodSignature * D.26477;
  short unsigned int D.26478;
  struct MonoClass * D.26479;
  unsigned char D.26480;
  _Bool D.26481;
  long int D.26482;
  long int D.26483;
  unsigned char D.26486;
  unsigned int rank.9;
  unsigned int D.26490;
  struct MonoArray * D.26492;
  struct MonoDomain * domain;
  uintptr_t lengths[3];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.26477 = mono_method_signature (cm);
      D.26478 = D.26477->param_count;
      pcount = (int) D.26478;
      D.26479 = cm->klass;
      D.26480 = D.26479->rank;
      rank = (int) D.26480;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      D.26481 = rank != pcount;
      D.26482 = (long int) D.26481;
      D.26483 = __builtin_expect (D.26482, 0);
      if (D.26483 != 0) goto <D.26484>; else goto <D.26485>;
      <D.26484>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 756, "rank == pcount");
      <D.26485>:
      D.26479 = cm->klass;
      D.26486 = D.26479->byval_arg.type;
      if (D.26486 == 20) goto <D.26487>; else goto <D.26488>;
      <D.26487>:
      rank.9 = (unsigned int) rank;
      D.26490 = rank.9 * 4;
      lower_bounds = __builtin_alloca (D.26490);
      rank.9 = (unsigned int) rank;
      D.26490 = rank.9 * 4;
      memset (lower_bounds, 0, D.26490);
      goto <D.26491>;
      <D.26488>:
      lower_bounds = 0B;
      <D.26491>:
      D.26479 = cm->klass;
      D.26492 = mono_array_new_full (domain, D.26479, &lengths, lower_bounds);
      return D.26492;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_4 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
{
  struct MonoMethodSignature * D.26495;
  short unsigned int D.26496;
  struct MonoClass * D.26497;
  unsigned char D.26498;
  _Bool D.26499;
  long int D.26500;
  long int D.26501;
  unsigned char D.26504;
  unsigned int rank.10;
  unsigned int D.26508;
  struct MonoArray * D.26510;
  struct MonoDomain * domain;
  uintptr_t lengths[4];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.26495 = mono_method_signature (cm);
      D.26496 = D.26495->param_count;
      pcount = (int) D.26496;
      D.26497 = cm->klass;
      D.26498 = D.26497->rank;
      rank = (int) D.26498;
      lengths[0] = length1;
      lengths[1] = length2;
      lengths[2] = length3;
      lengths[3] = length4;
      D.26499 = rank != pcount;
      D.26500 = (long int) D.26499;
      D.26501 = __builtin_expect (D.26500, 0);
      if (D.26501 != 0) goto <D.26502>; else goto <D.26503>;
      <D.26502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 787, "rank == pcount");
      <D.26503>:
      D.26497 = cm->klass;
      D.26504 = D.26497->byval_arg.type;
      if (D.26504 == 20) goto <D.26505>; else goto <D.26506>;
      <D.26505>:
      rank.10 = (unsigned int) rank;
      D.26508 = rank.10 * 4;
      lower_bounds = __builtin_alloca (D.26508);
      rank.10 = (unsigned int) rank;
      D.26508 = rank.10 * 4;
      memset (lower_bounds, 0, D.26508);
      goto <D.26509>;
      <D.26506>:
      lower_bounds = 0B;
      <D.26509>:
      D.26497 = cm->klass;
      D.26510 = mono_array_new_full (domain, D.26497, &lengths, lower_bounds);
      return D.26510;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_class_static_field_address (struct MonoDomain * domain, struct MonoClassField * field)
{
  struct MonoClass * D.26513;
  unsigned char D.26514;
  unsigned char D.26515;
  struct GHashTable * D.26520;
  unsigned int addr.11;
  void * D.26524;
  int D.26525;
  sizetype D.26526;
  void * D.26527;
  struct MonoVTable * vtable;
  void * addr;

  D.26513 = field->parent;
  mono_class_init (D.26513);
  D.26513 = field->parent;
  vtable = mono_class_vtable_full (domain, D.26513, 1);
  D.26514 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.26515 = D.26514 & 2;
  if (D.26515 == 0) goto <D.26516>; else goto <D.26517>;
  <D.26516>:
  mono_runtime_class_init (vtable);
  <D.26517>:
  D.26520 = domain->special_static_fields;
  if (D.26520 != 0B) goto <D.26521>; else goto <D.26518>;
  <D.26521>:
  D.26520 = domain->special_static_fields;
  addr = monoeg_g_hash_table_lookup (D.26520, field);
  if (addr != 0B) goto <D.26522>; else goto <D.26518>;
  <D.26522>:
  addr.11 = (unsigned int) addr;
  addr = mono_get_special_static_data (addr.11);
  goto <D.26519>;
  <D.26518>:
  D.26524 = mono_vtable_get_static_field_data (vtable);
  D.26525 = field->offset;
  D.26526 = (sizetype) D.26525;
  addr = D.26524 + D.26526;
  <D.26519>:
  D.26527 = addr;
  return D.26527;
}


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

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


mono_ldtoken_wrapper_generic_shared (struct MonoImage * image, int token, struct MonoMethod * method)
{
  unsigned char D.26534;
  unsigned char D.26535;
  _Bool D.26539;
  long int D.26540;
  long int D.26541;
  void * D.26544;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;

  sig = mono_method_signature (method);
  D.26534 = BIT_FIELD_REF <*sig, 8, 88>;
  D.26535 = D.26534 & 2;
  if (D.26535 != 0) goto <D.26536>; else goto <D.26537>;
  <D.26536>:
  generic_context = mono_method_get_context (method);
  goto <D.26538>;
  <D.26537>:
  {
    struct MonoGenericContainer * generic_container;

    generic_container = mono_method_get_generic_container (method);
    D.26539 = generic_container == 0B;
    D.26540 = (long int) D.26539;
    D.26541 = __builtin_expect (D.26540, 0);
    if (D.26541 != 0) goto <D.26542>; else goto <D.26543>;
    <D.26542>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 848, "generic_container");
    <D.26543>:
    generic_context = &generic_container->context;
  }
  <D.26538>:
  D.26544 = mono_ldtoken_wrapper (image, token, generic_context);
  return D.26544;
}


mono_fconv_u8 (double v)
{
  guint64 D.26546;

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


mono_fconv_i8 (double v)
{
  gint64 D.26548;

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


mono_fconv_u4 (double v)
{
  guint32 D.26550;

  D.26550 = (guint32) v;
  return D.26550;
}


mono_fconv_ovf_i8 (double v)
{
  double D.26555;
  double D.26556;
  struct MonoException * D.26557;
  gint64 D.26558;
  gint64 res;

  res = (gint64) v;
  if (v unord v) goto <D.26552>; else goto <D.26554>;
  <D.26554>:
  D.26555 = trunc (v);
  D.26556 = (double) res;
  if (D.26555 != D.26556) goto <D.26552>; else goto <D.26553>;
  <D.26552>:
  D.26557 = mono_get_exception_overflow ();
  mono_raise_exception (D.26557);
  <D.26553>:
  D.26558 = res;
  return D.26558;
}


mono_fconv_ovf_u8 (double v)
{
  double D.26563;
  double D.26564;
  struct MonoException * D.26565;
  guint64 D.26566;
  guint64 res;

  res = (guint64) v;
  if (v unord v) goto <D.26560>; else goto <D.26562>;
  <D.26562>:
  D.26563 = trunc (v);
  D.26564 = (double) res;
  if (D.26563 != D.26564) goto <D.26560>; else goto <D.26561>;
  <D.26560>:
  D.26565 = mono_get_exception_overflow ();
  mono_raise_exception (D.26565);
  <D.26561>:
  D.26566 = res;
  return D.26566;
}


mono_lconv_to_r8 (gint64 a)
{
  double D.26568;

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


mono_lconv_to_r4 (gint64 a)
{
  float D.26570;

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


mono_conv_to_r8_un (guint32 a)
{
  double D.26572;

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


mono_lconv_to_r8_un (guint64 a)
{
  double D.26574;

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


mono_helper_compile_generic_method (struct MonoObject * obj, struct MonoMethod * method, void * * this_arg)
{
  int D.26576;
  int D.26577;
  struct MonoException * D.26580;
  struct MonoClass * D.26581;
  struct MonoGenericContainer * D.26582;
  _Bool D.26583;
  long int D.26584;
  long int D.26585;
  int iftmp.14;
  struct MonoGenericClass * D.26591;
  struct MonoGenericInst * D.26593;
  unsigned char D.26594;
  unsigned char D.26595;
  _Bool D.26597;
  long int D.26598;
  long int D.26599;
  int iftmp.15;
  struct MonoGenericInst * D.26605;
  unsigned char D.26607;
  unsigned char D.26608;
  _Bool D.26610;
  long int D.26611;
  long int D.26612;
  int D.26615;
  struct MonoVTable * D.26616;
  struct MonoClass * D.26617;
  unsigned char D.26618;
  unsigned char D.26619;
  void * D.26622;
  void * D.26624;
  struct MonoMethod * vmethod;
  void * addr;
  struct MonoGenericContext * context;

  context = mono_method_get_context (method);
  D.26576 = mono_jit_stats.generic_virtual_invocations;
  D.26577 = D.26576 + 1;
  mono_jit_stats.generic_virtual_invocations = D.26577;
  if (obj == 0B) goto <D.26578>; else goto <D.26579>;
  <D.26578>:
  D.26580 = mono_get_exception_null_reference ();
  mono_raise_exception (D.26580);
  <D.26579>:
  vmethod = mono_object_get_virtual_method (obj, method);
  D.26581 = vmethod->klass;
  D.26582 = D.26581->generic_container;
  D.26583 = D.26582 != 0B;
  D.26584 = (long int) D.26583;
  D.26585 = __builtin_expect (D.26584, 0);
  if (D.26585 != 0) goto <D.26586>; else goto <D.26587>;
  <D.26586>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 993, "!vmethod->klass->generic_container");
  <D.26587>:
  D.26581 = vmethod->klass;
  D.26591 = D.26581->generic_class;
  if (D.26591 != 0B) goto <D.26592>; else goto <D.26589>;
  <D.26592>:
  D.26581 = vmethod->klass;
  D.26591 = D.26581->generic_class;
  D.26593 = D.26591->context.class_inst;
  D.26594 = BIT_FIELD_REF <*D.26593, 8, 48>;
  D.26595 = D.26594 & 64;
  if (D.26595 != 0) goto <D.26596>; else goto <D.26589>;
  <D.26596>:
  iftmp.14 = 1;
  goto <D.26590>;
  <D.26589>:
  iftmp.14 = 0;
  <D.26590>:
  D.26597 = iftmp.14 != 0;
  D.26598 = (long int) D.26597;
  D.26599 = __builtin_expect (D.26598, 0);
  if (D.26599 != 0) goto <D.26600>; else goto <D.26601>;
  <D.26600>:
  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.26601>:
  D.26605 = context->method_inst;
  if (D.26605 != 0B) goto <D.26606>; else goto <D.26603>;
  <D.26606>:
  D.26605 = context->method_inst;
  D.26607 = BIT_FIELD_REF <*D.26605, 8, 48>;
  D.26608 = D.26607 & 64;
  if (D.26608 != 0) goto <D.26609>; else goto <D.26603>;
  <D.26609>:
  iftmp.15 = 1;
  goto <D.26604>;
  <D.26603>:
  iftmp.15 = 0;
  <D.26604>:
  D.26610 = iftmp.15 != 0;
  D.26611 = (long int) D.26610;
  D.26612 = __builtin_expect (D.26611, 0);
  if (D.26612 != 0) goto <D.26613>; else goto <D.26614>;
  <D.26613>:
  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.26614>:
  addr = mono_compile_method (vmethod);
  D.26615 = mono_method_needs_static_rgctx_invoke (vmethod, 0);
  addr = mini_add_method_trampoline (0B, vmethod, addr, D.26615, 0);
  D.26616 = obj->vtable;
  D.26617 = D.26616->klass;
  D.26618 = BIT_FIELD_REF <*D.26617, 8, 160>;
  D.26619 = D.26618 & 8;
  if (D.26619 != 0) goto <D.26620>; else goto <D.26621>;
  <D.26620>:
  D.26622 = mono_object_unbox (obj);
  *this_arg = D.26622;
  goto <D.26623>;
  <D.26621>:
  *this_arg = obj;
  <D.26623>:
  D.26624 = addr;
  return D.26624;
}


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

  D.26627 = mono_domain_get ();
  D.26626 = mono_ldstr (D.26627, image, idx);
  return D.26626;
}


mono_helper_ldstr_mscorlib (guint32 idx)
{
  struct MonoString * D.26629;
  struct MonoDomain * D.26630;
  struct MonoImage * D.26631;

  D.26630 = mono_domain_get ();
  D.26631 = mono_defaults.corlib;
  D.26629 = mono_ldstr (D.26630, D.26631, idx);
  return D.26629;
}


mono_helper_newobj_mscorlib (guint32 idx)
{
  struct MonoImage * D.26633;
  unsigned int D.26634;
  _Bool D.26635;
  long int D.26636;
  long int D.26637;
  struct MonoObject * D.26640;
  struct MonoDomain * D.26641;
  struct MonoClass * klass;

  D.26633 = mono_defaults.corlib;
  D.26634 = idx | 33554432;
  klass = mono_class_get (D.26633, D.26634);
  D.26635 = klass == 0B;
  D.26636 = (long int) D.26635;
  D.26637 = __builtin_expect (D.26636, 0);
  if (D.26637 != 0) goto <D.26638>; else goto <D.26639>;
  <D.26638>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1027, "klass");
  <D.26639>:
  D.26641 = mono_domain_get ();
  D.26640 = mono_object_new (D.26641, klass);
  return D.26640;
}


mono_break ()
{

}


mono_create_corlib_exception_0 (guint32 token)
{
  struct MonoException * D.26643;
  struct MonoImage * D.26644;

  D.26644 = mono_defaults.corlib;
  D.26643 = mono_exception_from_token (D.26644, token);
  return D.26643;
}


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

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


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

  D.26650 = mono_defaults.corlib;
  D.26649 = mono_exception_from_token_two_strings (D.26650, token, arg1, arg2);
  return D.26649;
}


mono_object_castclass_unbox (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoDebugOptions * D.26652;
  int D.26653;
  unsigned int mono_jit_tls_id.16;
  struct MonoObject * D.26659;
  unsigned char D.26660;
  unsigned char D.26661;
  struct MonoVTable * D.26664;
  struct MonoClass * D.26665;
  struct MonoClass * D.26666;
  struct MonoObject * D.26669;
  struct MonoDebugOptions * D.26672;
  int D.26673;
  struct MonoImage * D.26676;
  struct MonoException * D.26677;
  struct MonoJitTlsData * jit_tls;

  jit_tls = 0B;
  D.26652 = mini_get_debug_options ();
  D.26653 = D.26652->better_cast_details;
  if (D.26653 != 0) goto <D.26654>; else goto <D.26655>;
  <D.26654>:
  mono_jit_tls_id.16 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.16);
  jit_tls->class_cast_from = 0B;
  <D.26655>:
  if (obj == 0B) goto <D.26657>; else goto <D.26658>;
  <D.26657>:
  D.26659 = 0B;
  return D.26659;
  <D.26658>:
  D.26660 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26661 = D.26660 & 16;
  if (D.26661 != 0) goto <D.26662>; else goto <D.26663>;
  <D.26662>:
  D.26664 = obj->vtable;
  D.26665 = D.26664->klass;
  D.26666 = klass->element_class;
  if (D.26665 == D.26666) goto <D.26667>; else goto <D.26668>;
  <D.26667>:
  D.26659 = obj;
  return D.26659;
  <D.26668>:
  <D.26663>:
  D.26669 = mono_object_isinst (obj, klass);
  if (D.26669 != 0B) goto <D.26670>; else goto <D.26671>;
  <D.26670>:
  D.26659 = obj;
  return D.26659;
  <D.26671>:
  D.26672 = mini_get_debug_options ();
  D.26673 = D.26672->better_cast_details;
  if (D.26673 != 0) goto <D.26674>; else goto <D.26675>;
  <D.26674>:
  D.26664 = obj->vtable;
  D.26665 = D.26664->klass;
  jit_tls->class_cast_from = D.26665;
  jit_tls->class_cast_to = klass;
  <D.26675>:
  D.26676 = mono_defaults.corlib;
  D.26677 = mono_exception_from_name (D.26676, "System", "InvalidCastException");
  mono_raise_exception (D.26677);
  D.26659 = 0B;
  return D.26659;
}


mono_object_castclass_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoDebugOptions * D.26679;
  int D.26680;
  unsigned int mono_jit_tls_id.17;
  struct MonoObject * D.26686;
  struct MonoObject * D.26689;
  struct MonoDebugOptions * D.26692;
  int D.26693;
  struct MonoVTable * D.26696;
  struct MonoClass * D.26697;
  struct MonoImage * D.26698;
  struct MonoException * D.26699;
  struct MonoJitTlsData * jit_tls;
  void * cached_vtable;
  void * obj_vtable;

  jit_tls = 0B;
  D.26679 = mini_get_debug_options ();
  D.26680 = D.26679->better_cast_details;
  if (D.26680 != 0) goto <D.26681>; else goto <D.26682>;
  <D.26681>:
  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.26682>:
  if (obj == 0B) goto <D.26684>; else goto <D.26685>;
  <D.26684>:
  D.26686 = 0B;
  return D.26686;
  <D.26685>:
  cached_vtable = *cache;
  obj_vtable = obj->vtable;
  if (cached_vtable == obj_vtable) goto <D.26687>; else goto <D.26688>;
  <D.26687>:
  D.26686 = obj;
  return D.26686;
  <D.26688>:
  D.26689 = mono_object_isinst (obj, klass);
  if (D.26689 != 0B) goto <D.26690>; else goto <D.26691>;
  <D.26690>:
  *cache = obj_vtable;
  D.26686 = obj;
  return D.26686;
  <D.26691>:
  D.26692 = mini_get_debug_options ();
  D.26693 = D.26692->better_cast_details;
  if (D.26693 != 0) goto <D.26694>; else goto <D.26695>;
  <D.26694>:
  D.26696 = obj->vtable;
  D.26697 = D.26696->klass;
  jit_tls->class_cast_from = D.26697;
  jit_tls->class_cast_to = klass;
  <D.26695>:
  D.26698 = mono_defaults.corlib;
  D.26699 = mono_exception_from_name (D.26698, "System", "InvalidCastException");
  mono_raise_exception (D.26699);
  D.26686 = 0B;
  return D.26686;
}


mono_object_isinst_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoObject * D.26703;
  void * D.26704;
  struct MonoVTable * D.26705;
  unsigned int D.26706;
  struct MonoObject * iftmp.18;
  unsigned int D.26710;
  struct MonoObject * D.26714;
  void * obj_vtable.19;
  unsigned int D.26718;
  void * D.26719;
  size_t cached_vtable;
  size_t obj_vtable;

  if (obj == 0B) goto <D.26701>; else goto <D.26702>;
  <D.26701>:
  D.26703 = 0B;
  return D.26703;
  <D.26702>:
  D.26704 = *cache;
  cached_vtable = (size_t) D.26704;
  D.26705 = obj->vtable;
  obj_vtable = (size_t) D.26705;
  D.26706 = cached_vtable & 4294967294;
  if (D.26706 == obj_vtable) goto <D.26707>; else goto <D.26708>;
  <D.26707>:
  D.26710 = cached_vtable & 1;
  if (D.26710 == 0) goto <D.26711>; else goto <D.26712>;
  <D.26711>:
  iftmp.18 = obj;
  goto <D.26713>;
  <D.26712>:
  iftmp.18 = 0B;
  <D.26713>:
  D.26703 = iftmp.18;
  return D.26703;
  <D.26708>:
  D.26714 = mono_object_isinst (obj, klass);
  if (D.26714 != 0B) goto <D.26715>; else goto <D.26716>;
  <D.26715>:
  obj_vtable.19 = (void *) obj_vtable;
  *cache = obj_vtable.19;
  D.26703 = obj;
  return D.26703;
  <D.26716>:
  D.26718 = obj_vtable | 1;
  D.26719 = (void *) D.26718;
  *cache = D.26719;
  D.26703 = 0B;
  return D.26703;
}


mono_get_native_calli_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, void * func)
{
  short unsigned int D.26721;
  int D.26722;
  int D.26723;
  unsigned int D.26724;
  unsigned int D.26725;
  void * D.26726;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct MonoMethod * m;

  try
    {
      D.26721 = sig->param_count;
      D.26722 = (int) D.26721;
      D.26723 = D.26722 + 1;
      D.26724 = (unsigned int) D.26723;
      D.26725 = D.26724 * 4;
      mspecs = monoeg_malloc0 (D.26725);
      memset (&piinfo, 0, 32);
      m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
      D.26726 = mono_compile_method (m);
      return D.26726;
    }
  finally
    {
      piinfo = {CLOBBER};
    }
}


mono_gsharedvt_constrained_call (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, gboolean deref_arg, void * * args)
{
  _Bool D.26729;
  _Bool D.26730;
  _Bool D.26731;
  void * D.26734;
  void * D.26735;
  unsigned char D.26736;
  unsigned char D.26737;
  void * this_arg.20;
  struct MonoObject * D.26741;
  struct MonoMethod * m;
  void * this_arg;
  void * new_args[16];

  try
    {
      m = constrained_gsharedvt_call_setup (mp, cmethod, klass, &this_arg);
      D.26729 = args != 0B;
      D.26730 = deref_arg != 0;
      D.26731 = D.26729 & D.26730;
      if (D.26731 != 0) goto <D.26732>; else goto <D.26733>;
      <D.26732>:
      D.26734 = *args;
      D.26735 = MEM[(void * *)D.26734];
      new_args[0] = D.26735;
      args = &new_args;
      <D.26733>:
      D.26736 = BIT_FIELD_REF <*m, 8, 160>;
      D.26737 = D.26736 & 124;
      if (D.26737 == 24) goto <D.26738>; else goto <D.26739>;
      <D.26738>:
      args = &new_args;
      this_arg.20 = this_arg;
      *args = this_arg.20;
      this_arg = 0B;
      <D.26739>:
      this_arg.20 = this_arg;
      D.26741 = mono_runtime_invoke (m, this_arg.20, args, 0B);
      return D.26741;
    }
  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.26744;
  unsigned int D.26745;
  struct MonoException * D.26748;
  struct MonoMethodSignature * D.26749;
  unsigned char D.26750;
  unsigned char D.26751;
  struct MonoMethod * * D.26755;
  _Bool D.26756;
  long int D.26757;
  long int D.26758;
  struct MonoClass * D.26761;
  unsigned int D.26762;
  unsigned int D.26763;
  _Bool D.26766;
  long int D.26767;
  long int D.26768;
  unsigned int vt_slot.21;
  unsigned int D.26772;
  struct MonoMethod * * D.26773;
  unsigned char D.26777;
  unsigned char D.26778;
  struct MonoClass * D.26780;
  struct MonoClass * D.26781;
  struct MonoClass * D.26783;
  struct MonoClass * D.26784;
  struct MonoDomain * D.26786;
  struct MonoObject * D.26787;
  void * D.26791;
  struct MonoMethod * D.26792;
  struct MonoMethod * m;
  int vt_slot;

  D.26744 = klass->flags;
  D.26745 = D.26744 & 32;
  if (D.26745 != 0) goto <D.26746>; else goto <D.26747>;
  <D.26746>:
  D.26748 = mono_get_exception_execution_engine ("Not yet supported.");
  mono_raise_exception (D.26748);
  <D.26747>:
  D.26749 = mono_method_signature (cmethod);
  D.26750 = BIT_FIELD_REF <*D.26749, 8, 88>;
  D.26751 = D.26750 & 1;
  if (D.26751 != 0) goto <D.26752>; else goto <D.26753>;
  <D.26752>:
  m = mono_marshal_get_native_wrapper (cmethod, 1, 0);
  goto <D.26754>;
  <D.26753>:
  mono_class_setup_vtable (klass);
  D.26755 = klass->vtable;
  D.26756 = D.26755 == 0B;
  D.26757 = (long int) D.26756;
  D.26758 = __builtin_expect (D.26757, 0);
  if (D.26758 != 0) goto <D.26759>; else goto <D.26760>;
  <D.26759>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1180, "klass->vtable");
  <D.26760>:
  vt_slot = mono_method_get_vtable_slot (cmethod);
  D.26761 = cmethod->klass;
  D.26762 = D.26761->flags;
  D.26763 = D.26762 & 32;
  if (D.26763 != 0) goto <D.26764>; else goto <D.26765>;
  <D.26764>:
  {
    int iface_offset;

    D.26761 = cmethod->klass;
    iface_offset = mono_class_interface_offset (klass, D.26761);
    D.26766 = iface_offset == -1;
    D.26767 = (long int) D.26766;
    D.26768 = __builtin_expect (D.26767, 0);
    if (D.26768 != 0) goto <D.26769>; else goto <D.26770>;
    <D.26769>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1186, "iface_offset != -1");
    <D.26770>:
    vt_slot = vt_slot + iface_offset;
  }
  <D.26765>:
  D.26755 = klass->vtable;
  vt_slot.21 = (unsigned int) vt_slot;
  D.26772 = vt_slot.21 * 4;
  D.26773 = D.26755 + D.26772;
  m = *D.26773;
  <D.26754>:
  D.26777 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26778 = D.26777 & 8;
  if (D.26778 != 0) goto <D.26779>; else goto <D.26774>;
  <D.26779>:
  D.26780 = m->klass;
  D.26781 = mono_defaults.object_class;
  if (D.26780 == D.26781) goto <D.26775>; else goto <D.26782>;
  <D.26782>:
  D.26780 = m->klass;
  D.26783 = mono_defaults.enum_class;
  D.26784 = D.26783->parent;
  if (D.26780 == D.26784) goto <D.26775>; else goto <D.26785>;
  <D.26785>:
  D.26780 = m->klass;
  D.26783 = mono_defaults.enum_class;
  if (D.26780 == D.26783) goto <D.26775>; else goto <D.26774>;
  <D.26775>:
  D.26786 = mono_domain_get ();
  D.26787 = mono_value_box (D.26786, klass, mp);
  *this_arg = D.26787;
  goto <D.26776>;
  <D.26774>:
  D.26777 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26778 = D.26777 & 8;
  if (D.26778 != 0) goto <D.26788>; else goto <D.26789>;
  <D.26788>:
  *this_arg = mp;
  goto <D.26790>;
  <D.26789>:
  D.26791 = MEM[(void * *)mp];
  *this_arg = D.26791;
  <D.26790>:
  <D.26776>:
  D.26792 = m;
  return D.26792;
}


mono_gsharedvt_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  unsigned char D.26794;
  unsigned char D.26795;
  struct MonoObject * D.26799;

  D.26794 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26795 = D.26794 & 8;
  if (D.26795 != 0) goto <D.26796>; else goto <D.26797>;
  <D.26796>:
  mono_value_copy (dest, src, klass);
  goto <D.26798>;
  <D.26797>:
  D.26799 = MEM[(struct MonoObject * *)src];
  mono_gc_wbarrier_generic_store (dest, D.26799);
  <D.26798>:
}