mono_ldftn (struct MonoMethod * method)
{
  struct MonoDomain * D.23869;
  void * D.23870;
  struct MonoDomain * D.23871;
  void * addr;

  D.23869 = mono_domain_get ();
  addr = mono_create_jump_trampoline (D.23869, method, 0);
  D.23871 = mono_domain_get ();
  D.23870 = mono_create_ftnptr (D.23871, addr);
  return D.23870;
}


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

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


ldvirtfn_internal (struct MonoObject * obj, struct MonoMethod * method, gboolean gshared)
{
  struct MonoException * D.23877;
  long unsigned int D.23880;
  long unsigned int D.23881;
  struct MonoGenericContext * D.23884;
  struct MonoGenericInst * D.23885;
  struct MonoClass * D.23888;
  struct MonoGenericClass * D.23889;
  struct MonoGenericInst * D.23892;
  struct MonoGenericContainer * D.23894;
  struct MonoGenericInst * D.23897;
  struct MonoGenericContext * D.23898;
  struct MonoGenericInst * D.23899;
  void * D.23900;
  struct MonoMethod * res;

  if (obj == 0B) goto <D.23875>; else goto <D.23876>;
  <D.23875>:
  D.23877 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23877);
  <D.23876>:
  res = mono_object_get_virtual_method (obj, method);
  if (gshared != 0) goto <D.23878>; else goto <D.23879>;
  <D.23878>:
  D.23880 = BIT_FIELD_REF <*method, 64, 256>;
  D.23881 = D.23880 & 4096;
  if (D.23881 != 0) goto <D.23882>; else goto <D.23883>;
  <D.23882>:
  D.23884 = mono_method_get_context (method);
  D.23885 = D.23884->method_inst;
  if (D.23885 != 0B) goto <D.23886>; else goto <D.23887>;
  <D.23886>:
  {
    struct MonoGenericContext context;

    try
      {
        context.class_inst = 0B;
        context.method_inst = 0B;
        D.23888 = res->klass;
        D.23889 = D.23888->generic_class;
        if (D.23889 != 0B) goto <D.23890>; else goto <D.23891>;
        <D.23890>:
        D.23888 = res->klass;
        D.23889 = D.23888->generic_class;
        D.23892 = D.23889->context.class_inst;
        context.class_inst = D.23892;
        goto <D.23893>;
        <D.23891>:
        D.23888 = res->klass;
        D.23894 = D.23888->generic_container;
        if (D.23894 != 0B) goto <D.23895>; else goto <D.23896>;
        <D.23895>:
        D.23888 = res->klass;
        D.23894 = D.23888->generic_container;
        D.23897 = D.23894->context.class_inst;
        context.class_inst = D.23897;
        <D.23896>:
        <D.23893>:
        D.23898 = mono_method_get_context (method);
        D.23899 = D.23898->method_inst;
        context.method_inst = D.23899;
        res = mono_class_inflate_generic_method (res, &context);
      }
    finally
      {
        context = {CLOBBER};
      }
  }
  <D.23887>:
  <D.23883>:
  <D.23879>:
  D.23900 = mono_ldftn (res);
  return D.23900;
}


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

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


mono_helper_stelem_ref_check (struct MonoArray * array, struct MonoObject * val)
{
  struct MonoException * D.23906;
  struct MonoVTable * D.23909;
  struct MonoClass * D.23910;
  struct MonoClass * D.23911;
  struct MonoObject * D.23912;
  struct MonoException * D.23915;

  if (array == 0B) goto <D.23904>; else goto <D.23905>;
  <D.23904>:
  D.23906 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23906);
  <D.23905>:
  if (val != 0B) goto <D.23907>; else goto <D.23908>;
  <D.23907>:
  D.23909 = array->obj.vtable;
  D.23910 = D.23909->klass;
  D.23911 = D.23910->element_class;
  D.23912 = mono_object_isinst (val, D.23911);
  if (D.23912 == 0B) goto <D.23913>; else goto <D.23914>;
  <D.23913>:
  D.23915 = mono_get_exception_array_type_mismatch ();
  mono_raise_exception (D.23915);
  <D.23914>:
  <D.23908>:
}


mono_array_new_va (struct MonoMethod * cm)
{
  struct MonoMethodSignature * D.23916;
  short unsigned int D.23917;
  struct MonoClass * D.23918;
  unsigned char D.23919;
  long unsigned int D.23920;
  long unsigned int D.23921;
  long unsigned int D.23922;
  long unsigned int D.23923;
  uintptr_t * D.23924;
  char * ap.0;
  char * ap.1;
  long unsigned int D.23927;
  unsigned char D.23930;
  long unsigned int D.23933;
  long unsigned int D.23934;
  int D.23937;
  _Bool D.23938;
  long int D.23939;
  long int D.23940;
  struct MonoArray * D.23943;
  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.23916 = mono_method_signature (cm);
      D.23917 = D.23916->param_count;
      pcount = (int) D.23917;
      D.23918 = cm->klass;
      D.23919 = D.23918->rank;
      rank = (int) D.23919;
      __builtin_va_start (&ap, 0);
      D.23920 = (long unsigned int) pcount;
      D.23921 = D.23920 * 8;
      lengths = __builtin_alloca (D.23921);
      i = 0;
      goto <D.23700>;
      <D.23699>:
      D.23922 = (long unsigned int) i;
      D.23923 = D.23922 * 8;
      D.23924 = lengths + D.23923;
      ap.0 = ap;
      ap.1 = ap.0 + 8;
      ap = ap.1;
      d = MEM[(int *)ap.0];
      D.23927 = (long unsigned int) d;
      *D.23924 = D.23927;
      i = i + 1;
      <D.23700>:
      if (i < pcount) goto <D.23699>; else goto <D.23701>;
      <D.23701>:
      if (rank == pcount) goto <D.23928>; else goto <D.23929>;
      <D.23928>:
      D.23918 = cm->klass;
      D.23930 = D.23918->byval_arg.type;
      if (D.23930 == 20) goto <D.23931>; else goto <D.23932>;
      <D.23931>:
      D.23933 = (long unsigned int) rank;
      D.23934 = D.23933 * 8;
      lower_bounds = __builtin_alloca (D.23934);
      D.23933 = (long unsigned int) rank;
      D.23934 = D.23933 * 8;
      memset (lower_bounds, 0, D.23934);
      goto <D.23935>;
      <D.23932>:
      lower_bounds = 0B;
      <D.23935>:
      goto <D.23936>;
      <D.23929>:
      D.23937 = rank * 2;
      D.23938 = D.23937 != pcount;
      D.23939 = (long int) D.23938;
      D.23940 = __builtin_expect (D.23939, 0);
      if (D.23940 != 0) goto <D.23941>; else goto <D.23942>;
      <D.23941>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 670, "pcount == (rank * 2)");
      <D.23942>:
      lower_bounds = lengths;
      D.23933 = (long unsigned int) rank;
      D.23934 = D.23933 * 8;
      lengths = lengths + D.23934;
      <D.23936>:
      __builtin_va_end (&ap);
      D.23918 = cm->klass;
      D.23943 = mono_array_new_full (domain, D.23918, lengths, lower_bounds);
      return D.23943;
    }
  finally
    {
      ap = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23948;
  int D.23953;
  void * D.23955;
  long unsigned int D.23956;

  D.23948 = __builtin_constant_p (__len);
  if (D.23948 != 0) goto <D.23949>; else goto <D.23950>;
  <D.23949>:
  if (__len == 0) goto <D.23951>; else goto <D.23952>;
  <D.23951>:
  D.23953 = __builtin_constant_p (__ch);
  if (D.23953 == 0) goto <D.23946>; else goto <D.23954>;
  <D.23954>:
  if (__ch != 0) goto <D.23946>; else goto <D.23947>;
  <D.23946>:
  __warn_memset_zero_len ();
  D.23955 = __dest;
  return D.23955;
  <D.23947>:
  <D.23952>:
  <D.23950>:
  D.23956 = __builtin_object_size (__dest, 0);
  D.23955 = __builtin___memset_chk (__dest, __ch, __len, D.23956);
  return D.23955;
}


mono_array_new_1 (struct MonoMethod * cm, guint32 length)
{
  struct MonoMethodSignature * D.23958;
  short unsigned int D.23959;
  struct MonoClass * D.23960;
  unsigned char D.23961;
  long unsigned int D.23962;
  _Bool D.23963;
  long int D.23964;
  long int D.23965;
  unsigned char D.23968;
  long unsigned int D.23971;
  long unsigned int D.23972;
  struct MonoArray * D.23974;
  struct MonoDomain * domain;
  uintptr_t lengths[1];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23958 = mono_method_signature (cm);
      D.23959 = D.23958->param_count;
      pcount = (int) D.23959;
      D.23960 = cm->klass;
      D.23961 = D.23960->rank;
      rank = (int) D.23961;
      D.23962 = (long unsigned int) length;
      lengths[0] = D.23962;
      D.23963 = rank != pcount;
      D.23964 = (long int) D.23963;
      D.23965 = __builtin_expect (D.23964, 0);
      if (D.23965 != 0) goto <D.23966>; else goto <D.23967>;
      <D.23966>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 697, "rank == pcount");
      <D.23967>:
      D.23960 = cm->klass;
      D.23968 = D.23960->byval_arg.type;
      if (D.23968 == 20) goto <D.23969>; else goto <D.23970>;
      <D.23969>:
      D.23971 = (long unsigned int) rank;
      D.23972 = D.23971 * 8;
      lower_bounds = __builtin_alloca (D.23972);
      D.23971 = (long unsigned int) rank;
      D.23972 = D.23971 * 8;
      memset (lower_bounds, 0, D.23972);
      goto <D.23973>;
      <D.23970>:
      lower_bounds = 0B;
      <D.23973>:
      D.23960 = cm->klass;
      D.23974 = mono_array_new_full (domain, D.23960, &lengths, lower_bounds);
      return D.23974;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_2 (struct MonoMethod * cm, guint32 length1, guint32 length2)
{
  struct MonoMethodSignature * D.23977;
  short unsigned int D.23978;
  struct MonoClass * D.23979;
  unsigned char D.23980;
  long unsigned int D.23981;
  long unsigned int D.23982;
  _Bool D.23983;
  long int D.23984;
  long int D.23985;
  unsigned char D.23988;
  long unsigned int D.23991;
  long unsigned int D.23992;
  struct MonoArray * D.23994;
  struct MonoDomain * domain;
  uintptr_t lengths[2];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23977 = mono_method_signature (cm);
      D.23978 = D.23977->param_count;
      pcount = (int) D.23978;
      D.23979 = cm->klass;
      D.23980 = D.23979->rank;
      rank = (int) D.23980;
      D.23981 = (long unsigned int) length1;
      lengths[0] = D.23981;
      D.23982 = (long unsigned int) length2;
      lengths[1] = D.23982;
      D.23983 = rank != pcount;
      D.23984 = (long int) D.23983;
      D.23985 = __builtin_expect (D.23984, 0);
      if (D.23985 != 0) goto <D.23986>; else goto <D.23987>;
      <D.23986>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 726, "rank == pcount");
      <D.23987>:
      D.23979 = cm->klass;
      D.23988 = D.23979->byval_arg.type;
      if (D.23988 == 20) goto <D.23989>; else goto <D.23990>;
      <D.23989>:
      D.23991 = (long unsigned int) rank;
      D.23992 = D.23991 * 8;
      lower_bounds = __builtin_alloca (D.23992);
      D.23991 = (long unsigned int) rank;
      D.23992 = D.23991 * 8;
      memset (lower_bounds, 0, D.23992);
      goto <D.23993>;
      <D.23990>:
      lower_bounds = 0B;
      <D.23993>:
      D.23979 = cm->klass;
      D.23994 = mono_array_new_full (domain, D.23979, &lengths, lower_bounds);
      return D.23994;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_3 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3)
{
  struct MonoMethodSignature * D.23997;
  short unsigned int D.23998;
  struct MonoClass * D.23999;
  unsigned char D.24000;
  long unsigned int D.24001;
  long unsigned int D.24002;
  long unsigned int D.24003;
  _Bool D.24004;
  long int D.24005;
  long int D.24006;
  unsigned char D.24009;
  long unsigned int D.24012;
  long unsigned int D.24013;
  struct MonoArray * D.24015;
  struct MonoDomain * domain;
  uintptr_t lengths[3];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.23997 = mono_method_signature (cm);
      D.23998 = D.23997->param_count;
      pcount = (int) D.23998;
      D.23999 = cm->klass;
      D.24000 = D.23999->rank;
      rank = (int) D.24000;
      D.24001 = (long unsigned int) length1;
      lengths[0] = D.24001;
      D.24002 = (long unsigned int) length2;
      lengths[1] = D.24002;
      D.24003 = (long unsigned int) length3;
      lengths[2] = D.24003;
      D.24004 = rank != pcount;
      D.24005 = (long int) D.24004;
      D.24006 = __builtin_expect (D.24005, 0);
      if (D.24006 != 0) goto <D.24007>; else goto <D.24008>;
      <D.24007>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 756, "rank == pcount");
      <D.24008>:
      D.23999 = cm->klass;
      D.24009 = D.23999->byval_arg.type;
      if (D.24009 == 20) goto <D.24010>; else goto <D.24011>;
      <D.24010>:
      D.24012 = (long unsigned int) rank;
      D.24013 = D.24012 * 8;
      lower_bounds = __builtin_alloca (D.24013);
      D.24012 = (long unsigned int) rank;
      D.24013 = D.24012 * 8;
      memset (lower_bounds, 0, D.24013);
      goto <D.24014>;
      <D.24011>:
      lower_bounds = 0B;
      <D.24014>:
      D.23999 = cm->klass;
      D.24015 = mono_array_new_full (domain, D.23999, &lengths, lower_bounds);
      return D.24015;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_array_new_4 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
{
  struct MonoMethodSignature * D.24018;
  short unsigned int D.24019;
  struct MonoClass * D.24020;
  unsigned char D.24021;
  long unsigned int D.24022;
  long unsigned int D.24023;
  long unsigned int D.24024;
  long unsigned int D.24025;
  _Bool D.24026;
  long int D.24027;
  long int D.24028;
  unsigned char D.24031;
  long unsigned int D.24034;
  long unsigned int D.24035;
  struct MonoArray * D.24037;
  struct MonoDomain * domain;
  uintptr_t lengths[4];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.24018 = mono_method_signature (cm);
      D.24019 = D.24018->param_count;
      pcount = (int) D.24019;
      D.24020 = cm->klass;
      D.24021 = D.24020->rank;
      rank = (int) D.24021;
      D.24022 = (long unsigned int) length1;
      lengths[0] = D.24022;
      D.24023 = (long unsigned int) length2;
      lengths[1] = D.24023;
      D.24024 = (long unsigned int) length3;
      lengths[2] = D.24024;
      D.24025 = (long unsigned int) length4;
      lengths[3] = D.24025;
      D.24026 = rank != pcount;
      D.24027 = (long int) D.24026;
      D.24028 = __builtin_expect (D.24027, 0);
      if (D.24028 != 0) goto <D.24029>; else goto <D.24030>;
      <D.24029>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 787, "rank == pcount");
      <D.24030>:
      D.24020 = cm->klass;
      D.24031 = D.24020->byval_arg.type;
      if (D.24031 == 20) goto <D.24032>; else goto <D.24033>;
      <D.24032>:
      D.24034 = (long unsigned int) rank;
      D.24035 = D.24034 * 8;
      lower_bounds = __builtin_alloca (D.24035);
      D.24034 = (long unsigned int) rank;
      D.24035 = D.24034 * 8;
      memset (lower_bounds, 0, D.24035);
      goto <D.24036>;
      <D.24033>:
      lower_bounds = 0B;
      <D.24036>:
      D.24020 = cm->klass;
      D.24037 = mono_array_new_full (domain, D.24020, &lengths, lower_bounds);
      return D.24037;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


mono_class_static_field_address (struct MonoDomain * domain, struct MonoClassField * field)
{
  struct MonoClass * D.24040;
  long unsigned int D.24041;
  long unsigned int D.24042;
  struct GHashTable * D.24047;
  long int addr.2;
  unsigned int D.24051;
  void * D.24052;
  int D.24053;
  sizetype D.24054;
  void * D.24055;
  struct MonoVTable * vtable;
  void * addr;

  D.24040 = field->parent;
  mono_class_init (D.24040);
  D.24040 = field->parent;
  vtable = mono_class_vtable_full (domain, D.24040, 1);
  D.24041 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.24042 = D.24041 & 33554432;
  if (D.24042 == 0) goto <D.24043>; else goto <D.24044>;
  <D.24043>:
  mono_runtime_class_init (vtable);
  <D.24044>:
  D.24047 = domain->special_static_fields;
  if (D.24047 != 0B) goto <D.24048>; else goto <D.24045>;
  <D.24048>:
  D.24047 = domain->special_static_fields;
  addr = monoeg_g_hash_table_lookup (D.24047, field);
  if (addr != 0B) goto <D.24049>; else goto <D.24045>;
  <D.24049>:
  addr.2 = (long int) addr;
  D.24051 = (unsigned int) addr.2;
  addr = mono_get_special_static_data (D.24051);
  goto <D.24046>;
  <D.24045>:
  D.24052 = mono_vtable_get_static_field_data (vtable);
  D.24053 = field->offset;
  D.24054 = (sizetype) D.24053;
  addr = D.24052 + D.24054;
  <D.24046>:
  D.24055 = addr;
  return D.24055;
}


mono_ldtoken_wrapper (struct MonoImage * image, int token, struct MonoGenericContext * context)
{
  unsigned int token.3;
  struct MonoClass * handle_class.4;
  void * D.24059;
  struct MonoClass * handle_class;
  void * res;

  try
    {
      token.3 = (unsigned int) token;
      res = mono_ldtoken (image, token.3, &handle_class, context);
      handle_class.4 = handle_class;
      mono_class_init (handle_class.4);
      D.24059 = res;
      return D.24059;
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


mono_ldtoken_wrapper_generic_shared (struct MonoImage * image, int token, struct MonoMethod * method)
{
  long unsigned int D.24062;
  long unsigned int D.24063;
  _Bool D.24067;
  long int D.24068;
  long int D.24069;
  void * D.24072;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;

  sig = mono_method_signature (method);
  D.24062 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24063 = D.24062 & 144115188075855872;
  if (D.24063 != 0) goto <D.24064>; else goto <D.24065>;
  <D.24064>:
  generic_context = mono_method_get_context (method);
  goto <D.24066>;
  <D.24065>:
  {
    struct MonoGenericContainer * generic_container;

    generic_container = mono_method_get_generic_container (method);
    D.24067 = generic_container == 0B;
    D.24068 = (long int) D.24067;
    D.24069 = __builtin_expect (D.24068, 0);
    if (D.24069 != 0) goto <D.24070>; else goto <D.24071>;
    <D.24070>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 848, "generic_container");
    <D.24071>:
    generic_context = &generic_container->context;
  }
  <D.24066>:
  D.24072 = mono_ldtoken_wrapper (image, token, generic_context);
  return D.24072;
}


mono_fconv_u8 (double v)
{
  guint64 D.24074;

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


mono_fconv_u4 (double v)
{
  int D.24078;
  int D.24080;
  guint32 D.24081;

  D.24078 = __isinf (v);
  if (D.24078 != 0) goto <D.24076>; else goto <D.24079>;
  <D.24079>:
  D.24080 = __isnan (v);
  if (D.24080 != 0) goto <D.24076>; else goto <D.24077>;
  <D.24076>:
  D.24081 = 0;
  return D.24081;
  <D.24077>:
  D.24081 = (guint32) v;
  return D.24081;
}


mono_fconv_ovf_i8 (double v)
{
  int D.24085;
  double D.24087;
  double D.24088;
  struct MonoException * D.24089;
  gint64 D.24090;
  gint64 res;

  res = (gint64) v;
  D.24085 = __isnan (v);
  if (D.24085 != 0) goto <D.24083>; else goto <D.24086>;
  <D.24086>:
  D.24087 = trunc (v);
  D.24088 = (double) res;
  if (D.24087 != D.24088) goto <D.24083>; else goto <D.24084>;
  <D.24083>:
  D.24089 = mono_get_exception_overflow ();
  mono_raise_exception (D.24089);
  <D.24084>:
  D.24090 = res;
  return D.24090;
}


mono_fconv_ovf_u8 (double v)
{
  int D.24094;
  double D.24096;
  double D.24097;
  struct MonoException * D.24098;
  guint64 D.24099;
  guint64 res;

  res = (guint64) v;
  D.24094 = __isnan (v);
  if (D.24094 != 0) goto <D.24092>; else goto <D.24095>;
  <D.24095>:
  D.24096 = trunc (v);
  D.24097 = (double) res;
  if (D.24096 != D.24097) goto <D.24092>; else goto <D.24093>;
  <D.24092>:
  D.24098 = mono_get_exception_overflow ();
  mono_raise_exception (D.24098);
  <D.24093>:
  D.24099 = res;
  return D.24099;
}


mono_lconv_to_r8_un (guint64 a)
{
  double D.24101;

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


mono_helper_compile_generic_method (struct MonoObject * obj, struct MonoMethod * method, void * * this_arg)
{
  int D.24103;
  int D.24104;
  struct MonoException * D.24107;
  struct MonoClass * D.24108;
  struct MonoGenericContainer * D.24109;
  _Bool D.24110;
  long int D.24111;
  long int D.24112;
  int iftmp.5;
  struct MonoGenericClass * D.24118;
  struct MonoGenericInst * D.24120;
  long unsigned int D.24121;
  long unsigned int D.24122;
  _Bool D.24124;
  long int D.24125;
  long int D.24126;
  int iftmp.6;
  struct MonoGenericInst * D.24132;
  long unsigned int D.24134;
  long unsigned int D.24135;
  _Bool D.24137;
  long int D.24138;
  long int D.24139;
  int D.24142;
  struct MonoVTable * D.24143;
  struct MonoClass * D.24144;
  long unsigned int D.24145;
  long unsigned int D.24146;
  void * D.24149;
  void * D.24151;
  struct MonoMethod * vmethod;
  void * addr;
  struct MonoGenericContext * context;

  context = mono_method_get_context (method);
  D.24103 = mono_jit_stats.generic_virtual_invocations;
  D.24104 = D.24103 + 1;
  mono_jit_stats.generic_virtual_invocations = D.24104;
  if (obj == 0B) goto <D.24105>; else goto <D.24106>;
  <D.24105>:
  D.24107 = mono_get_exception_null_reference ();
  mono_raise_exception (D.24107);
  <D.24106>:
  vmethod = mono_object_get_virtual_method (obj, method);
  D.24108 = vmethod->klass;
  D.24109 = D.24108->generic_container;
  D.24110 = D.24109 != 0B;
  D.24111 = (long int) D.24110;
  D.24112 = __builtin_expect (D.24111, 0);
  if (D.24112 != 0) goto <D.24113>; else goto <D.24114>;
  <D.24113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 993, "!vmethod->klass->generic_container");
  <D.24114>:
  D.24108 = vmethod->klass;
  D.24118 = D.24108->generic_class;
  if (D.24118 != 0B) goto <D.24119>; else goto <D.24116>;
  <D.24119>:
  D.24108 = vmethod->klass;
  D.24118 = D.24108->generic_class;
  D.24120 = D.24118->context.class_inst;
  D.24121 = BIT_FIELD_REF <*D.24120, 64, 0>;
  D.24122 = D.24121 & 18014398509481984;
  if (D.24122 != 0) goto <D.24123>; else goto <D.24116>;
  <D.24123>:
  iftmp.5 = 1;
  goto <D.24117>;
  <D.24116>:
  iftmp.5 = 0;
  <D.24117>:
  D.24124 = iftmp.5 != 0;
  D.24125 = (long int) D.24124;
  D.24126 = __builtin_expect (D.24125, 0);
  if (D.24126 != 0) goto <D.24127>; else goto <D.24128>;
  <D.24127>:
  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.24128>:
  D.24132 = context->method_inst;
  if (D.24132 != 0B) goto <D.24133>; else goto <D.24130>;
  <D.24133>:
  D.24132 = context->method_inst;
  D.24134 = BIT_FIELD_REF <*D.24132, 64, 0>;
  D.24135 = D.24134 & 18014398509481984;
  if (D.24135 != 0) goto <D.24136>; else goto <D.24130>;
  <D.24136>:
  iftmp.6 = 1;
  goto <D.24131>;
  <D.24130>:
  iftmp.6 = 0;
  <D.24131>:
  D.24137 = iftmp.6 != 0;
  D.24138 = (long int) D.24137;
  D.24139 = __builtin_expect (D.24138, 0);
  if (D.24139 != 0) goto <D.24140>; else goto <D.24141>;
  <D.24140>:
  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.24141>:
  addr = mono_compile_method (vmethod);
  D.24142 = mono_method_needs_static_rgctx_invoke (vmethod, 0);
  addr = mini_add_method_trampoline (0B, vmethod, addr, D.24142, 0);
  D.24143 = obj->vtable;
  D.24144 = D.24143->klass;
  D.24145 = BIT_FIELD_REF <*D.24144, 64, 256>;
  D.24146 = D.24145 & 8;
  if (D.24146 != 0) goto <D.24147>; else goto <D.24148>;
  <D.24147>:
  D.24149 = mono_object_unbox (obj);
  *this_arg = D.24149;
  goto <D.24150>;
  <D.24148>:
  *this_arg = obj;
  <D.24150>:
  D.24151 = addr;
  return D.24151;
}


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

  D.24154 = mono_domain_get ();
  D.24153 = mono_ldstr (D.24154, image, idx);
  return D.24153;
}


mono_helper_ldstr_mscorlib (guint32 idx)
{
  struct MonoString * D.24156;
  struct MonoDomain * D.24157;
  struct MonoImage * D.24158;

  D.24157 = mono_domain_get ();
  D.24158 = mono_defaults.corlib;
  D.24156 = mono_ldstr (D.24157, D.24158, idx);
  return D.24156;
}


mono_helper_newobj_mscorlib (guint32 idx)
{
  struct MonoImage * D.24160;
  unsigned int D.24161;
  _Bool D.24162;
  long int D.24163;
  long int D.24164;
  struct MonoObject * D.24167;
  struct MonoDomain * D.24168;
  struct MonoClass * klass;

  D.24160 = mono_defaults.corlib;
  D.24161 = idx | 33554432;
  klass = mono_class_get (D.24160, D.24161);
  D.24162 = klass == 0B;
  D.24163 = (long int) D.24162;
  D.24164 = __builtin_expect (D.24163, 0);
  if (D.24164 != 0) goto <D.24165>; else goto <D.24166>;
  <D.24165>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1027, "klass");
  <D.24166>:
  D.24168 = mono_domain_get ();
  D.24167 = mono_object_new (D.24168, klass);
  return D.24167;
}


mono_break ()
{

}


mono_create_corlib_exception_0 (guint32 token)
{
  struct MonoException * D.24170;
  struct MonoImage * D.24171;

  D.24171 = mono_defaults.corlib;
  D.24170 = mono_exception_from_token (D.24171, token);
  return D.24170;
}


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

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


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

  D.24177 = mono_defaults.corlib;
  D.24176 = mono_exception_from_token_two_strings (D.24177, token, arg1, arg2);
  return D.24176;
}


mono_object_castclass_unbox (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoDebugOptions * D.24179;
  int D.24180;
  unsigned int mono_jit_tls_id.7;
  struct MonoObject * D.24186;
  long unsigned int D.24187;
  long unsigned int D.24188;
  struct MonoVTable * D.24191;
  struct MonoClass * D.24192;
  struct MonoClass * D.24193;
  struct MonoObject * D.24196;
  struct MonoDebugOptions * D.24199;
  int D.24200;
  struct MonoImage * D.24203;
  struct MonoException * D.24204;
  struct MonoJitTlsData * jit_tls;

  jit_tls = 0B;
  D.24179 = mini_get_debug_options ();
  D.24180 = D.24179->better_cast_details;
  if (D.24180 != 0) goto <D.24181>; else goto <D.24182>;
  <D.24181>:
  mono_jit_tls_id.7 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.7);
  jit_tls->class_cast_from = 0B;
  <D.24182>:
  if (obj == 0B) goto <D.24184>; else goto <D.24185>;
  <D.24184>:
  D.24186 = 0B;
  return D.24186;
  <D.24185>:
  D.24187 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24188 = D.24187 & 16;
  if (D.24188 != 0) goto <D.24189>; else goto <D.24190>;
  <D.24189>:
  D.24191 = obj->vtable;
  D.24192 = D.24191->klass;
  D.24193 = klass->element_class;
  if (D.24192 == D.24193) goto <D.24194>; else goto <D.24195>;
  <D.24194>:
  D.24186 = obj;
  return D.24186;
  <D.24195>:
  <D.24190>:
  D.24196 = mono_object_isinst (obj, klass);
  if (D.24196 != 0B) goto <D.24197>; else goto <D.24198>;
  <D.24197>:
  D.24186 = obj;
  return D.24186;
  <D.24198>:
  D.24199 = mini_get_debug_options ();
  D.24200 = D.24199->better_cast_details;
  if (D.24200 != 0) goto <D.24201>; else goto <D.24202>;
  <D.24201>:
  D.24191 = obj->vtable;
  D.24192 = D.24191->klass;
  jit_tls->class_cast_from = D.24192;
  jit_tls->class_cast_to = klass;
  <D.24202>:
  D.24203 = mono_defaults.corlib;
  D.24204 = mono_exception_from_name (D.24203, "System", "InvalidCastException");
  mono_raise_exception (D.24204);
  D.24186 = 0B;
  return D.24186;
}


mono_object_castclass_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoDebugOptions * D.24206;
  int D.24207;
  unsigned int mono_jit_tls_id.8;
  struct MonoObject * D.24213;
  struct MonoObject * D.24216;
  struct MonoDebugOptions * D.24219;
  int D.24220;
  struct MonoVTable * D.24223;
  struct MonoClass * D.24224;
  struct MonoImage * D.24225;
  struct MonoException * D.24226;
  struct MonoJitTlsData * jit_tls;
  void * cached_vtable;
  void * obj_vtable;

  jit_tls = 0B;
  D.24206 = mini_get_debug_options ();
  D.24207 = D.24206->better_cast_details;
  if (D.24207 != 0) goto <D.24208>; else goto <D.24209>;
  <D.24208>:
  mono_jit_tls_id.8 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.8);
  jit_tls->class_cast_from = 0B;
  <D.24209>:
  if (obj == 0B) goto <D.24211>; else goto <D.24212>;
  <D.24211>:
  D.24213 = 0B;
  return D.24213;
  <D.24212>:
  cached_vtable = *cache;
  obj_vtable = obj->vtable;
  if (cached_vtable == obj_vtable) goto <D.24214>; else goto <D.24215>;
  <D.24214>:
  D.24213 = obj;
  return D.24213;
  <D.24215>:
  D.24216 = mono_object_isinst (obj, klass);
  if (D.24216 != 0B) goto <D.24217>; else goto <D.24218>;
  <D.24217>:
  *cache = obj_vtable;
  D.24213 = obj;
  return D.24213;
  <D.24218>:
  D.24219 = mini_get_debug_options ();
  D.24220 = D.24219->better_cast_details;
  if (D.24220 != 0) goto <D.24221>; else goto <D.24222>;
  <D.24221>:
  D.24223 = obj->vtable;
  D.24224 = D.24223->klass;
  jit_tls->class_cast_from = D.24224;
  jit_tls->class_cast_to = klass;
  <D.24222>:
  D.24225 = mono_defaults.corlib;
  D.24226 = mono_exception_from_name (D.24225, "System", "InvalidCastException");
  mono_raise_exception (D.24226);
  D.24213 = 0B;
  return D.24213;
}


mono_object_isinst_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoObject * D.24230;
  void * D.24231;
  struct MonoVTable * D.24232;
  long unsigned int D.24233;
  struct MonoObject * iftmp.9;
  long unsigned int D.24237;
  struct MonoObject * D.24241;
  void * obj_vtable.10;
  long unsigned int D.24245;
  void * D.24246;
  size_t cached_vtable;
  size_t obj_vtable;

  if (obj == 0B) goto <D.24228>; else goto <D.24229>;
  <D.24228>:
  D.24230 = 0B;
  return D.24230;
  <D.24229>:
  D.24231 = *cache;
  cached_vtable = (size_t) D.24231;
  D.24232 = obj->vtable;
  obj_vtable = (size_t) D.24232;
  D.24233 = cached_vtable & 18446744073709551614;
  if (D.24233 == obj_vtable) goto <D.24234>; else goto <D.24235>;
  <D.24234>:
  D.24237 = cached_vtable & 1;
  if (D.24237 == 0) goto <D.24238>; else goto <D.24239>;
  <D.24238>:
  iftmp.9 = obj;
  goto <D.24240>;
  <D.24239>:
  iftmp.9 = 0B;
  <D.24240>:
  D.24230 = iftmp.9;
  return D.24230;
  <D.24235>:
  D.24241 = mono_object_isinst (obj, klass);
  if (D.24241 != 0B) goto <D.24242>; else goto <D.24243>;
  <D.24242>:
  obj_vtable.10 = (void *) obj_vtable;
  *cache = obj_vtable.10;
  D.24230 = obj;
  return D.24230;
  <D.24243>:
  D.24245 = obj_vtable | 1;
  D.24246 = (void *) D.24245;
  *cache = D.24246;
  D.24230 = 0B;
  return D.24230;
}


mono_get_native_calli_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, void * func)
{
  short unsigned int D.24248;
  int D.24249;
  int D.24250;
  long unsigned int D.24251;
  long unsigned int D.24252;
  void * D.24253;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct MonoMethod * m;

  try
    {
      D.24248 = sig->param_count;
      D.24249 = (int) D.24248;
      D.24250 = D.24249 + 1;
      D.24251 = (long unsigned int) D.24250;
      D.24252 = D.24251 * 8;
      mspecs = monoeg_malloc0 (D.24252);
      memset (&piinfo, 0, 56);
      m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
      D.24253 = mono_compile_method (m);
      return D.24253;
    }
  finally
    {
      piinfo = {CLOBBER};
    }
}


mono_gsharedvt_constrained_call (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, gboolean deref_arg, void * * args)
{
  void * D.24260;
  void * D.24261;
  long unsigned int D.24262;
  long unsigned int D.24263;
  void * this_arg.11;
  struct MonoObject * D.24267;
  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.24256>; else goto <D.24257>;
      <D.24256>:
      if (deref_arg != 0) goto <D.24258>; else goto <D.24259>;
      <D.24258>:
      D.24260 = *args;
      D.24261 = MEM[(void * *)D.24260];
      new_args[0] = D.24261;
      args = &new_args;
      <D.24259>:
      <D.24257>:
      D.24262 = BIT_FIELD_REF <*m, 64, 256>;
      D.24263 = D.24262 & 124;
      if (D.24263 == 24) goto <D.24264>; else goto <D.24265>;
      <D.24264>:
      args = &new_args;
      this_arg.11 = this_arg;
      *args = this_arg.11;
      this_arg = 0B;
      <D.24265>:
      this_arg.11 = this_arg;
      D.24267 = mono_runtime_invoke (m, this_arg.11, args, 0B);
      return D.24267;
    }
  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.24270;
  unsigned int D.24271;
  struct MonoException * D.24274;
  struct MonoMethodSignature * D.24275;
  long unsigned int D.24276;
  long unsigned int D.24277;
  struct MonoMethod * * D.24281;
  _Bool D.24282;
  long int D.24283;
  long int D.24284;
  struct MonoClass * D.24287;
  unsigned int D.24288;
  unsigned int D.24289;
  _Bool D.24292;
  long int D.24293;
  long int D.24294;
  long unsigned int D.24297;
  long unsigned int D.24298;
  struct MonoMethod * * D.24299;
  long unsigned int D.24303;
  long unsigned int D.24304;
  struct MonoClass * D.24306;
  struct MonoClass * D.24307;
  struct MonoClass * D.24309;
  struct MonoClass * D.24310;
  struct MonoDomain * D.24312;
  struct MonoObject * D.24313;
  void * D.24317;
  struct MonoMethod * D.24318;
  struct MonoMethod * m;
  int vt_slot;

  D.24270 = klass->flags;
  D.24271 = D.24270 & 32;
  if (D.24271 != 0) goto <D.24272>; else goto <D.24273>;
  <D.24272>:
  D.24274 = mono_get_exception_execution_engine ("Not yet supported.");
  mono_raise_exception (D.24274);
  <D.24273>:
  D.24275 = mono_method_signature (cmethod);
  D.24276 = BIT_FIELD_REF <*D.24275, 64, 64>;
  D.24277 = D.24276 & 72057594037927936;
  if (D.24277 != 0) goto <D.24278>; else goto <D.24279>;
  <D.24278>:
  m = mono_marshal_get_native_wrapper (cmethod, 1, 0);
  goto <D.24280>;
  <D.24279>:
  mono_class_setup_vtable (klass);
  D.24281 = klass->vtable;
  D.24282 = D.24281 == 0B;
  D.24283 = (long int) D.24282;
  D.24284 = __builtin_expect (D.24283, 0);
  if (D.24284 != 0) goto <D.24285>; else goto <D.24286>;
  <D.24285>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1180, "klass->vtable");
  <D.24286>:
  vt_slot = mono_method_get_vtable_slot (cmethod);
  D.24287 = cmethod->klass;
  D.24288 = D.24287->flags;
  D.24289 = D.24288 & 32;
  if (D.24289 != 0) goto <D.24290>; else goto <D.24291>;
  <D.24290>:
  {
    int iface_offset;

    D.24287 = cmethod->klass;
    iface_offset = mono_class_interface_offset (klass, D.24287);
    D.24292 = iface_offset == -1;
    D.24293 = (long int) D.24292;
    D.24294 = __builtin_expect (D.24293, 0);
    if (D.24294 != 0) goto <D.24295>; else goto <D.24296>;
    <D.24295>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1186, "iface_offset != -1");
    <D.24296>:
    vt_slot = vt_slot + iface_offset;
  }
  <D.24291>:
  D.24281 = klass->vtable;
  D.24297 = (long unsigned int) vt_slot;
  D.24298 = D.24297 * 8;
  D.24299 = D.24281 + D.24298;
  m = *D.24299;
  <D.24280>:
  D.24303 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24304 = D.24303 & 8;
  if (D.24304 != 0) goto <D.24305>; else goto <D.24300>;
  <D.24305>:
  D.24306 = m->klass;
  D.24307 = mono_defaults.object_class;
  if (D.24306 == D.24307) goto <D.24301>; else goto <D.24308>;
  <D.24308>:
  D.24306 = m->klass;
  D.24309 = mono_defaults.enum_class;
  D.24310 = D.24309->parent;
  if (D.24306 == D.24310) goto <D.24301>; else goto <D.24311>;
  <D.24311>:
  D.24306 = m->klass;
  D.24309 = mono_defaults.enum_class;
  if (D.24306 == D.24309) goto <D.24301>; else goto <D.24300>;
  <D.24301>:
  D.24312 = mono_domain_get ();
  D.24313 = mono_value_box (D.24312, klass, mp);
  *this_arg = D.24313;
  goto <D.24302>;
  <D.24300>:
  D.24303 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24304 = D.24303 & 8;
  if (D.24304 != 0) goto <D.24314>; else goto <D.24315>;
  <D.24314>:
  *this_arg = mp;
  goto <D.24316>;
  <D.24315>:
  D.24317 = MEM[(void * *)mp];
  *this_arg = D.24317;
  <D.24316>:
  <D.24302>:
  D.24318 = m;
  return D.24318;
}


mono_gsharedvt_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  long unsigned int D.24320;
  long unsigned int D.24321;
  struct MonoObject * D.24325;

  D.24320 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24321 = D.24320 & 8;
  if (D.24321 != 0) goto <D.24322>; else goto <D.24323>;
  <D.24322>:
  mono_value_copy (dest, src, klass);
  goto <D.24324>;
  <D.24323>:
  D.24325 = MEM[(struct MonoObject * *)src];
  mono_gc_wbarrier_generic_store (dest, D.24325);
  <D.24324>:
}