__attribute__((visibility ("hidden")))
mono_ldftn (struct MonoMethod * method)
{
  struct MonoDomain * D.23949;
  void * D.23950;
  struct MonoDomain * D.23951;
  void * addr;

  D.23949 = mono_domain_get ();
  addr = mono_create_jump_trampoline (D.23949, method, 0);
  D.23951 = mono_domain_get ();
  D.23950 = mono_create_ftnptr (D.23951, addr);
  return D.23950;
}


__attribute__((visibility ("hidden")))
mono_ldvirtfn (struct MonoObject * obj, struct MonoMethod * method)
{
  void * D.23953;

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


ldvirtfn_internal (struct MonoObject * obj, struct MonoMethod * method, gboolean gshared)
{
  struct MonoException * D.23957;
  long unsigned int D.23960;
  long unsigned int D.23961;
  struct MonoGenericContext * D.23964;
  struct MonoGenericInst * D.23965;
  struct MonoClass * D.23968;
  struct MonoGenericClass * D.23969;
  struct MonoGenericInst * D.23972;
  struct MonoGenericContainer * D.23974;
  struct MonoGenericInst * D.23977;
  struct MonoGenericContext * D.23978;
  struct MonoGenericInst * D.23979;
  void * D.23980;
  struct MonoMethod * res;

  if (obj == 0B) goto <D.23955>; else goto <D.23956>;
  <D.23955>:
  D.23957 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23957);
  <D.23956>:
  res = mono_object_get_virtual_method (obj, method);
  if (gshared != 0) goto <D.23958>; else goto <D.23959>;
  <D.23958>:
  D.23960 = BIT_FIELD_REF <*method, 64, 256>;
  D.23961 = D.23960 & 2251799813685248;
  if (D.23961 != 0) goto <D.23962>; else goto <D.23963>;
  <D.23962>:
  D.23964 = mono_method_get_context (method);
  D.23965 = D.23964->method_inst;
  if (D.23965 != 0B) goto <D.23966>; else goto <D.23967>;
  <D.23966>:
  {
    struct MonoGenericContext context;

    try
      {
        context.class_inst = 0B;
        context.method_inst = 0B;
        D.23968 = res->klass;
        D.23969 = D.23968->generic_class;
        if (D.23969 != 0B) goto <D.23970>; else goto <D.23971>;
        <D.23970>:
        D.23968 = res->klass;
        D.23969 = D.23968->generic_class;
        D.23972 = D.23969->context.class_inst;
        context.class_inst = D.23972;
        goto <D.23973>;
        <D.23971>:
        D.23968 = res->klass;
        D.23974 = D.23968->generic_container;
        if (D.23974 != 0B) goto <D.23975>; else goto <D.23976>;
        <D.23975>:
        D.23968 = res->klass;
        D.23974 = D.23968->generic_container;
        D.23977 = D.23974->context.class_inst;
        context.class_inst = D.23977;
        <D.23976>:
        <D.23973>:
        D.23978 = mono_method_get_context (method);
        D.23979 = D.23978->method_inst;
        context.method_inst = D.23979;
        res = mono_class_inflate_generic_method (res, &context);
      }
    finally
      {
        context = {CLOBBER};
      }
  }
  <D.23967>:
  <D.23963>:
  <D.23959>:
  D.23980 = mono_ldftn (res);
  return D.23980;
}


__attribute__((visibility ("hidden")))
mono_ldvirtfn_gshared (struct MonoObject * obj, struct MonoMethod * method)
{
  void * D.23982;

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


__attribute__((visibility ("hidden")))
mono_helper_stelem_ref_check (struct MonoArray * array, struct MonoObject * val)
{
  struct MonoException * D.23986;
  struct MonoVTable * D.23989;
  struct MonoClass * D.23990;
  struct MonoClass * D.23991;
  struct MonoObject * D.23992;
  struct MonoException * D.23995;

  if (array == 0B) goto <D.23984>; else goto <D.23985>;
  <D.23984>:
  D.23986 = mono_get_exception_null_reference ();
  mono_raise_exception (D.23986);
  <D.23985>:
  if (val != 0B) goto <D.23987>; else goto <D.23988>;
  <D.23987>:
  D.23989 = array->obj.vtable;
  D.23990 = D.23989->klass;
  D.23991 = D.23990->element_class;
  D.23992 = mono_object_isinst (val, D.23991);
  if (D.23992 == 0B) goto <D.23993>; else goto <D.23994>;
  <D.23993>:
  D.23995 = mono_get_exception_array_type_mismatch ();
  mono_raise_exception (D.23995);
  <D.23994>:
  <D.23988>:
}


__attribute__((visibility ("hidden")))
mono_array_new_va (struct MonoMethod * cm)
{
  struct MonoMethodSignature * D.23996;
  short unsigned int D.23997;
  struct MonoClass * D.23998;
  unsigned char D.23999;
  long unsigned int D.24000;
  long unsigned int D.24001;
  long unsigned int D.24002;
  long unsigned int D.24003;
  uintptr_t * D.24004;
  long unsigned int D.24005;
  unsigned char D.24008;
  long unsigned int D.24011;
  long unsigned int D.24012;
  int D.24015;
  _Bool D.24016;
  long int D.24017;
  long int D.24018;
  struct MonoArray * D.24021;
  struct MonoDomain * domain;
  struct  ap[1];
  uintptr_t * lengths;
  intptr_t * lower_bounds;
  int pcount;
  int rank;
  int i;
  int d;

  try
    {
      domain = mono_domain_get ();
      D.23996 = mono_method_signature (cm);
      D.23997 = D.23996->param_count;
      pcount = (int) D.23997;
      D.23998 = cm->klass;
      D.23999 = D.23998->rank;
      rank = (int) D.23999;
      __builtin_va_start (&ap, 0);
      D.24000 = (long unsigned int) pcount;
      D.24001 = D.24000 * 8;
      lengths = __builtin_alloca (D.24001);
      i = 0;
      goto <D.23780>;
      <D.23779>:
      D.24002 = (long unsigned int) i;
      D.24003 = D.24002 * 8;
      D.24004 = lengths + D.24003;
      d = VA_ARG (&ap, 0B, 0B);
      D.24005 = (long unsigned int) d;
      *D.24004 = D.24005;
      i = i + 1;
      <D.23780>:
      if (i < pcount) goto <D.23779>; else goto <D.23781>;
      <D.23781>:
      if (rank == pcount) goto <D.24006>; else goto <D.24007>;
      <D.24006>:
      D.23998 = cm->klass;
      D.24008 = D.23998->byval_arg.type;
      if (D.24008 == 20) goto <D.24009>; else goto <D.24010>;
      <D.24009>:
      D.24011 = (long unsigned int) rank;
      D.24012 = D.24011 * 8;
      lower_bounds = __builtin_alloca (D.24012);
      D.24011 = (long unsigned int) rank;
      D.24012 = D.24011 * 8;
      memset (lower_bounds, 0, D.24012);
      goto <D.24013>;
      <D.24010>:
      lower_bounds = 0B;
      <D.24013>:
      goto <D.24014>;
      <D.24007>:
      D.24015 = rank * 2;
      D.24016 = D.24015 != pcount;
      D.24017 = (long int) D.24016;
      D.24018 = __builtin_expect (D.24017, 0);
      if (D.24018 != 0) goto <D.24019>; else goto <D.24020>;
      <D.24019>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 670, "pcount == (rank * 2)");
      <D.24020>:
      lower_bounds = lengths;
      D.24011 = (long unsigned int) rank;
      D.24012 = D.24011 * 8;
      lengths = lengths + D.24012;
      <D.24014>:
      __builtin_va_end (&ap);
      D.23998 = cm->klass;
      D.24021 = mono_array_new_full (domain, D.23998, lengths, lower_bounds);
      return D.24021;
    }
  finally
    {
      ap = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.24024;
  long unsigned int D.24025;

  D.24025 = __builtin_object_size (__dest, 0);
  D.24024 = __builtin___memset_chk (__dest, __ch, __len, D.24025);
  return D.24024;
}


__attribute__((visibility ("hidden")))
mono_array_new_1 (struct MonoMethod * cm, guint32 length)
{
  struct MonoMethodSignature * D.24027;
  short unsigned int D.24028;
  struct MonoClass * D.24029;
  unsigned char D.24030;
  long unsigned int D.24031;
  _Bool D.24032;
  long int D.24033;
  long int D.24034;
  unsigned char D.24037;
  long unsigned int D.24040;
  long unsigned int D.24041;
  struct MonoArray * D.24043;
  struct MonoDomain * domain;
  uintptr_t lengths[1];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.24027 = mono_method_signature (cm);
      D.24028 = D.24027->param_count;
      pcount = (int) D.24028;
      D.24029 = cm->klass;
      D.24030 = D.24029->rank;
      rank = (int) D.24030;
      D.24031 = (long unsigned int) length;
      lengths[0] = D.24031;
      D.24032 = rank != pcount;
      D.24033 = (long int) D.24032;
      D.24034 = __builtin_expect (D.24033, 0);
      if (D.24034 != 0) goto <D.24035>; else goto <D.24036>;
      <D.24035>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 697, "rank == pcount");
      <D.24036>:
      D.24029 = cm->klass;
      D.24037 = D.24029->byval_arg.type;
      if (D.24037 == 20) goto <D.24038>; else goto <D.24039>;
      <D.24038>:
      D.24040 = (long unsigned int) rank;
      D.24041 = D.24040 * 8;
      lower_bounds = __builtin_alloca (D.24041);
      D.24040 = (long unsigned int) rank;
      D.24041 = D.24040 * 8;
      memset (lower_bounds, 0, D.24041);
      goto <D.24042>;
      <D.24039>:
      lower_bounds = 0B;
      <D.24042>:
      D.24029 = cm->klass;
      D.24043 = mono_array_new_full (domain, D.24029, &lengths, lower_bounds);
      return D.24043;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_array_new_2 (struct MonoMethod * cm, guint32 length1, guint32 length2)
{
  struct MonoMethodSignature * D.24046;
  short unsigned int D.24047;
  struct MonoClass * D.24048;
  unsigned char D.24049;
  long unsigned int D.24050;
  long unsigned int D.24051;
  _Bool D.24052;
  long int D.24053;
  long int D.24054;
  unsigned char D.24057;
  long unsigned int D.24060;
  long unsigned int D.24061;
  struct MonoArray * D.24063;
  struct MonoDomain * domain;
  uintptr_t lengths[2];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.24046 = mono_method_signature (cm);
      D.24047 = D.24046->param_count;
      pcount = (int) D.24047;
      D.24048 = cm->klass;
      D.24049 = D.24048->rank;
      rank = (int) D.24049;
      D.24050 = (long unsigned int) length1;
      lengths[0] = D.24050;
      D.24051 = (long unsigned int) length2;
      lengths[1] = D.24051;
      D.24052 = rank != pcount;
      D.24053 = (long int) D.24052;
      D.24054 = __builtin_expect (D.24053, 0);
      if (D.24054 != 0) goto <D.24055>; else goto <D.24056>;
      <D.24055>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 726, "rank == pcount");
      <D.24056>:
      D.24048 = cm->klass;
      D.24057 = D.24048->byval_arg.type;
      if (D.24057 == 20) goto <D.24058>; else goto <D.24059>;
      <D.24058>:
      D.24060 = (long unsigned int) rank;
      D.24061 = D.24060 * 8;
      lower_bounds = __builtin_alloca (D.24061);
      D.24060 = (long unsigned int) rank;
      D.24061 = D.24060 * 8;
      memset (lower_bounds, 0, D.24061);
      goto <D.24062>;
      <D.24059>:
      lower_bounds = 0B;
      <D.24062>:
      D.24048 = cm->klass;
      D.24063 = mono_array_new_full (domain, D.24048, &lengths, lower_bounds);
      return D.24063;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_array_new_3 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3)
{
  struct MonoMethodSignature * D.24066;
  short unsigned int D.24067;
  struct MonoClass * D.24068;
  unsigned char D.24069;
  long unsigned int D.24070;
  long unsigned int D.24071;
  long unsigned int D.24072;
  _Bool D.24073;
  long int D.24074;
  long int D.24075;
  unsigned char D.24078;
  long unsigned int D.24081;
  long unsigned int D.24082;
  struct MonoArray * D.24084;
  struct MonoDomain * domain;
  uintptr_t lengths[3];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.24066 = mono_method_signature (cm);
      D.24067 = D.24066->param_count;
      pcount = (int) D.24067;
      D.24068 = cm->klass;
      D.24069 = D.24068->rank;
      rank = (int) D.24069;
      D.24070 = (long unsigned int) length1;
      lengths[0] = D.24070;
      D.24071 = (long unsigned int) length2;
      lengths[1] = D.24071;
      D.24072 = (long unsigned int) length3;
      lengths[2] = D.24072;
      D.24073 = rank != pcount;
      D.24074 = (long int) D.24073;
      D.24075 = __builtin_expect (D.24074, 0);
      if (D.24075 != 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 756, "rank == pcount");
      <D.24077>:
      D.24068 = cm->klass;
      D.24078 = D.24068->byval_arg.type;
      if (D.24078 == 20) goto <D.24079>; else goto <D.24080>;
      <D.24079>:
      D.24081 = (long unsigned int) rank;
      D.24082 = D.24081 * 8;
      lower_bounds = __builtin_alloca (D.24082);
      D.24081 = (long unsigned int) rank;
      D.24082 = D.24081 * 8;
      memset (lower_bounds, 0, D.24082);
      goto <D.24083>;
      <D.24080>:
      lower_bounds = 0B;
      <D.24083>:
      D.24068 = cm->klass;
      D.24084 = mono_array_new_full (domain, D.24068, &lengths, lower_bounds);
      return D.24084;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_array_new_4 (struct MonoMethod * cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
{
  struct MonoMethodSignature * D.24087;
  short unsigned int D.24088;
  struct MonoClass * D.24089;
  unsigned char D.24090;
  long unsigned int D.24091;
  long unsigned int D.24092;
  long unsigned int D.24093;
  long unsigned int D.24094;
  _Bool D.24095;
  long int D.24096;
  long int D.24097;
  unsigned char D.24100;
  long unsigned int D.24103;
  long unsigned int D.24104;
  struct MonoArray * D.24106;
  struct MonoDomain * domain;
  uintptr_t lengths[4];
  intptr_t * lower_bounds;
  int pcount;
  int rank;

  try
    {
      domain = mono_domain_get ();
      D.24087 = mono_method_signature (cm);
      D.24088 = D.24087->param_count;
      pcount = (int) D.24088;
      D.24089 = cm->klass;
      D.24090 = D.24089->rank;
      rank = (int) D.24090;
      D.24091 = (long unsigned int) length1;
      lengths[0] = D.24091;
      D.24092 = (long unsigned int) length2;
      lengths[1] = D.24092;
      D.24093 = (long unsigned int) length3;
      lengths[2] = D.24093;
      D.24094 = (long unsigned int) length4;
      lengths[3] = D.24094;
      D.24095 = rank != pcount;
      D.24096 = (long int) D.24095;
      D.24097 = __builtin_expect (D.24096, 0);
      if (D.24097 != 0) goto <D.24098>; else goto <D.24099>;
      <D.24098>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 787, "rank == pcount");
      <D.24099>:
      D.24089 = cm->klass;
      D.24100 = D.24089->byval_arg.type;
      if (D.24100 == 20) goto <D.24101>; else goto <D.24102>;
      <D.24101>:
      D.24103 = (long unsigned int) rank;
      D.24104 = D.24103 * 8;
      lower_bounds = __builtin_alloca (D.24104);
      D.24103 = (long unsigned int) rank;
      D.24104 = D.24103 * 8;
      memset (lower_bounds, 0, D.24104);
      goto <D.24105>;
      <D.24102>:
      lower_bounds = 0B;
      <D.24105>:
      D.24089 = cm->klass;
      D.24106 = mono_array_new_full (domain, D.24089, &lengths, lower_bounds);
      return D.24106;
    }
  finally
    {
      lengths = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_static_field_address (struct MonoDomain * domain, struct MonoClassField * field)
{
  struct MonoClass * D.24109;
  long unsigned int D.24110;
  long unsigned int D.24111;
  struct GHashTable * D.24116;
  long int addr.0;
  unsigned int D.24120;
  void * D.24121;
  int D.24122;
  sizetype D.24123;
  void * D.24124;
  struct MonoVTable * vtable;
  void * addr;

  D.24109 = field->parent;
  mono_class_init (D.24109);
  D.24109 = field->parent;
  vtable = mono_class_vtable_full (domain, D.24109, 1);
  D.24110 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.24111 = D.24110 & 274877906944;
  if (D.24111 == 0) goto <D.24112>; else goto <D.24113>;
  <D.24112>:
  mono_runtime_class_init (vtable);
  <D.24113>:
  D.24116 = domain->special_static_fields;
  if (D.24116 != 0B) goto <D.24117>; else goto <D.24114>;
  <D.24117>:
  D.24116 = domain->special_static_fields;
  addr = monoeg_g_hash_table_lookup (D.24116, field);
  if (addr != 0B) goto <D.24118>; else goto <D.24114>;
  <D.24118>:
  addr.0 = (long int) addr;
  D.24120 = (unsigned int) addr.0;
  addr = mono_get_special_static_data (D.24120);
  goto <D.24115>;
  <D.24114>:
  D.24121 = mono_vtable_get_static_field_data (vtable);
  D.24122 = field->offset;
  D.24123 = (sizetype) D.24122;
  addr = D.24121 + D.24123;
  <D.24115>:
  D.24124 = addr;
  return D.24124;
}


__attribute__((visibility ("hidden")))
mono_ldtoken_wrapper (struct MonoImage * image, int token, struct MonoGenericContext * context)
{
  unsigned int token.1;
  struct MonoClass * handle_class.2;
  void * D.24128;
  struct MonoClass * handle_class;
  void * res;

  try
    {
      token.1 = (unsigned int) token;
      res = mono_ldtoken (image, token.1, &handle_class, context);
      handle_class.2 = handle_class;
      mono_class_init (handle_class.2);
      D.24128 = res;
      return D.24128;
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_ldtoken_wrapper_generic_shared (struct MonoImage * image, int token, struct MonoMethod * method)
{
  long unsigned int D.24131;
  long unsigned int D.24132;
  _Bool D.24136;
  long int D.24137;
  long int D.24138;
  void * D.24141;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;

  sig = mono_method_signature (method);
  D.24131 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24132 = D.24131 & 64;
  if (D.24132 != 0) goto <D.24133>; else goto <D.24134>;
  <D.24133>:
  generic_context = mono_method_get_context (method);
  goto <D.24135>;
  <D.24134>:
  {
    struct MonoGenericContainer * generic_container;

    generic_container = mono_method_get_generic_container (method);
    D.24136 = generic_container == 0B;
    D.24137 = (long int) D.24136;
    D.24138 = __builtin_expect (D.24137, 0);
    if (D.24138 != 0) goto <D.24139>; else goto <D.24140>;
    <D.24139>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 848, "generic_container");
    <D.24140>:
    generic_context = &generic_container->context;
  }
  <D.24135>:
  D.24141 = mono_ldtoken_wrapper (image, token, generic_context);
  return D.24141;
}


__attribute__((visibility ("hidden")))
mono_fconv_u8 (double v)
{
  guint64 D.24143;

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


__attribute__((visibility ("hidden")))
mono_fconv_u4 (double v)
{
  guint32 D.24145;

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


__attribute__((visibility ("hidden")))
mono_fconv_ovf_i8 (double v)
{
  double D.24150;
  double D.24151;
  struct MonoException * D.24152;
  gint64 D.24153;
  gint64 res;

  res = (gint64) v;
  if (v unord v) goto <D.24147>; else goto <D.24149>;
  <D.24149>:
  D.24150 = trunc (v);
  D.24151 = (double) res;
  if (D.24150 != D.24151) goto <D.24147>; else goto <D.24148>;
  <D.24147>:
  D.24152 = mono_get_exception_overflow ();
  mono_raise_exception (D.24152);
  <D.24148>:
  D.24153 = res;
  return D.24153;
}


__attribute__((visibility ("hidden")))
mono_fconv_ovf_u8 (double v)
{
  double D.24158;
  double D.24159;
  struct MonoException * D.24160;
  guint64 D.24161;
  guint64 res;

  res = (guint64) v;
  if (v unord v) goto <D.24155>; else goto <D.24157>;
  <D.24157>:
  D.24158 = trunc (v);
  D.24159 = (double) res;
  if (D.24158 != D.24159) goto <D.24155>; else goto <D.24156>;
  <D.24155>:
  D.24160 = mono_get_exception_overflow ();
  mono_raise_exception (D.24160);
  <D.24156>:
  D.24161 = res;
  return D.24161;
}


__attribute__((visibility ("hidden")))
mono_lconv_to_r8_un (guint64 a)
{
  double D.24163;

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


__attribute__((visibility ("hidden")))
mono_helper_compile_generic_method (struct MonoObject * obj, struct MonoMethod * method, void * * this_arg)
{
  int D.24165;
  int D.24166;
  struct MonoException * D.24169;
  struct MonoClass * D.24170;
  struct MonoGenericContainer * D.24171;
  _Bool D.24172;
  long int D.24173;
  long int D.24174;
  int iftmp.3;
  struct MonoGenericClass * D.24180;
  struct MonoGenericInst * D.24182;
  long unsigned int D.24183;
  long unsigned int D.24184;
  _Bool D.24186;
  long int D.24187;
  long int D.24188;
  int iftmp.4;
  struct MonoGenericInst * D.24194;
  long unsigned int D.24196;
  long unsigned int D.24197;
  _Bool D.24199;
  long int D.24200;
  long int D.24201;
  int D.24204;
  struct MonoVTable * D.24205;
  struct MonoClass * D.24206;
  long unsigned int D.24207;
  long unsigned int D.24208;
  void * D.24211;
  void * D.24213;
  struct MonoMethod * vmethod;
  void * addr;
  struct MonoGenericContext * context;

  context = mono_method_get_context (method);
  D.24165 = mono_jit_stats.generic_virtual_invocations;
  D.24166 = D.24165 + 1;
  mono_jit_stats.generic_virtual_invocations = D.24166;
  if (obj == 0B) goto <D.24167>; else goto <D.24168>;
  <D.24167>:
  D.24169 = mono_get_exception_null_reference ();
  mono_raise_exception (D.24169);
  <D.24168>:
  vmethod = mono_object_get_virtual_method (obj, method);
  D.24170 = vmethod->klass;
  D.24171 = D.24170->generic_container;
  D.24172 = D.24171 != 0B;
  D.24173 = (long int) D.24172;
  D.24174 = __builtin_expect (D.24173, 0);
  if (D.24174 != 0) goto <D.24175>; else goto <D.24176>;
  <D.24175>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 993, "!vmethod->klass->generic_container");
  <D.24176>:
  D.24170 = vmethod->klass;
  D.24180 = D.24170->generic_class;
  if (D.24180 != 0B) goto <D.24181>; else goto <D.24178>;
  <D.24181>:
  D.24170 = vmethod->klass;
  D.24180 = D.24170->generic_class;
  D.24182 = D.24180->context.class_inst;
  D.24183 = BIT_FIELD_REF <*D.24182, 64, 0>;
  D.24184 = D.24183 & 512;
  if (D.24184 != 0) goto <D.24185>; else goto <D.24178>;
  <D.24185>:
  iftmp.3 = 1;
  goto <D.24179>;
  <D.24178>:
  iftmp.3 = 0;
  <D.24179>:
  D.24186 = iftmp.3 != 0;
  D.24187 = (long int) D.24186;
  D.24188 = __builtin_expect (D.24187, 0);
  if (D.24188 != 0) goto <D.24189>; else goto <D.24190>;
  <D.24189>:
  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.24190>:
  D.24194 = context->method_inst;
  if (D.24194 != 0B) goto <D.24195>; else goto <D.24192>;
  <D.24195>:
  D.24194 = context->method_inst;
  D.24196 = BIT_FIELD_REF <*D.24194, 64, 0>;
  D.24197 = D.24196 & 512;
  if (D.24197 != 0) goto <D.24198>; else goto <D.24192>;
  <D.24198>:
  iftmp.4 = 1;
  goto <D.24193>;
  <D.24192>:
  iftmp.4 = 0;
  <D.24193>:
  D.24199 = iftmp.4 != 0;
  D.24200 = (long int) D.24199;
  D.24201 = __builtin_expect (D.24200, 0);
  if (D.24201 != 0) goto <D.24202>; else goto <D.24203>;
  <D.24202>:
  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.24203>:
  addr = mono_compile_method (vmethod);
  D.24204 = mono_method_needs_static_rgctx_invoke (vmethod, 0);
  addr = mini_add_method_trampoline (0B, vmethod, addr, D.24204, 0);
  D.24205 = obj->vtable;
  D.24206 = D.24205->klass;
  D.24207 = BIT_FIELD_REF <*D.24206, 64, 256>;
  D.24208 = D.24207 & 1152921504606846976;
  if (D.24208 != 0) goto <D.24209>; else goto <D.24210>;
  <D.24209>:
  D.24211 = mono_object_unbox (obj);
  *this_arg = D.24211;
  goto <D.24212>;
  <D.24210>:
  *this_arg = obj;
  <D.24212>:
  D.24213 = addr;
  return D.24213;
}


__attribute__((visibility ("hidden")))
mono_helper_ldstr (struct MonoImage * image, guint32 idx)
{
  struct MonoString * D.24215;
  struct MonoDomain * D.24216;

  D.24216 = mono_domain_get ();
  D.24215 = mono_ldstr (D.24216, image, idx);
  return D.24215;
}


__attribute__((visibility ("hidden")))
mono_helper_ldstr_mscorlib (guint32 idx)
{
  struct MonoString * D.24218;
  struct MonoDomain * D.24219;
  struct MonoImage * D.24220;

  D.24219 = mono_domain_get ();
  D.24220 = mono_defaults.corlib;
  D.24218 = mono_ldstr (D.24219, D.24220, idx);
  return D.24218;
}


__attribute__((visibility ("hidden")))
mono_helper_newobj_mscorlib (guint32 idx)
{
  struct MonoImage * D.24222;
  unsigned int D.24223;
  _Bool D.24224;
  long int D.24225;
  long int D.24226;
  struct MonoObject * D.24229;
  struct MonoDomain * D.24230;
  struct MonoClass * klass;

  D.24222 = mono_defaults.corlib;
  D.24223 = idx | 33554432;
  klass = mono_class_get (D.24222, D.24223);
  D.24224 = klass == 0B;
  D.24225 = (long int) D.24224;
  D.24226 = __builtin_expect (D.24225, 0);
  if (D.24226 != 0) goto <D.24227>; else goto <D.24228>;
  <D.24227>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1027, "klass");
  <D.24228>:
  D.24230 = mono_domain_get ();
  D.24229 = mono_object_new (D.24230, klass);
  return D.24229;
}


__attribute__((visibility ("hidden")))
mono_break ()
{

}


__attribute__((visibility ("hidden")))
mono_create_corlib_exception_0 (guint32 token)
{
  struct MonoException * D.24232;
  struct MonoImage * D.24233;

  D.24233 = mono_defaults.corlib;
  D.24232 = mono_exception_from_token (D.24233, token);
  return D.24232;
}


__attribute__((visibility ("hidden")))
mono_create_corlib_exception_1 (guint32 token, struct MonoString * arg)
{
  struct MonoException * D.24235;
  struct MonoImage * D.24236;

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


__attribute__((visibility ("hidden")))
mono_create_corlib_exception_2 (guint32 token, struct MonoString * arg1, struct MonoString * arg2)
{
  struct MonoException * D.24238;
  struct MonoImage * D.24239;

  D.24239 = mono_defaults.corlib;
  D.24238 = mono_exception_from_token_two_strings (D.24239, token, arg1, arg2);
  return D.24238;
}


__attribute__((visibility ("hidden")))
mono_object_castclass_unbox (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoDebugOptions * D.24241;
  int D.24242;
  unsigned int mono_jit_tls_id.5;
  struct MonoObject * D.24248;
  long unsigned int D.24249;
  long unsigned int D.24250;
  struct MonoVTable * D.24253;
  struct MonoClass * D.24254;
  struct MonoClass * D.24255;
  struct MonoObject * D.24258;
  struct MonoDebugOptions * D.24261;
  int D.24262;
  struct MonoImage * D.24265;
  struct MonoException * D.24266;
  struct MonoJitTlsData * jit_tls;

  jit_tls = 0B;
  D.24241 = mini_get_debug_options ();
  D.24242 = D.24241->better_cast_details;
  if (D.24242 != 0) goto <D.24243>; else goto <D.24244>;
  <D.24243>:
  mono_jit_tls_id.5 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.5);
  jit_tls->class_cast_from = 0B;
  <D.24244>:
  if (obj == 0B) goto <D.24246>; else goto <D.24247>;
  <D.24246>:
  D.24248 = 0B;
  return D.24248;
  <D.24247>:
  D.24249 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24250 = D.24249 & 576460752303423488;
  if (D.24250 != 0) goto <D.24251>; else goto <D.24252>;
  <D.24251>:
  D.24253 = obj->vtable;
  D.24254 = D.24253->klass;
  D.24255 = klass->element_class;
  if (D.24254 == D.24255) goto <D.24256>; else goto <D.24257>;
  <D.24256>:
  D.24248 = obj;
  return D.24248;
  <D.24257>:
  <D.24252>:
  D.24258 = mono_object_isinst (obj, klass);
  if (D.24258 != 0B) goto <D.24259>; else goto <D.24260>;
  <D.24259>:
  D.24248 = obj;
  return D.24248;
  <D.24260>:
  D.24261 = mini_get_debug_options ();
  D.24262 = D.24261->better_cast_details;
  if (D.24262 != 0) goto <D.24263>; else goto <D.24264>;
  <D.24263>:
  D.24253 = obj->vtable;
  D.24254 = D.24253->klass;
  jit_tls->class_cast_from = D.24254;
  jit_tls->class_cast_to = klass;
  <D.24264>:
  D.24265 = mono_defaults.corlib;
  D.24266 = mono_exception_from_name (D.24265, "System", "InvalidCastException");
  mono_raise_exception (D.24266);
  D.24248 = 0B;
  return D.24248;
}


mono_object_castclass_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoDebugOptions * D.24268;
  int D.24269;
  unsigned int mono_jit_tls_id.6;
  struct MonoObject * D.24275;
  struct MonoObject * D.24278;
  struct MonoDebugOptions * D.24281;
  int D.24282;
  struct MonoVTable * D.24285;
  struct MonoClass * D.24286;
  struct MonoImage * D.24287;
  struct MonoException * D.24288;
  struct MonoJitTlsData * jit_tls;
  void * cached_vtable;
  void * obj_vtable;

  jit_tls = 0B;
  D.24268 = mini_get_debug_options ();
  D.24269 = D.24268->better_cast_details;
  if (D.24269 != 0) goto <D.24270>; else goto <D.24271>;
  <D.24270>:
  mono_jit_tls_id.6 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.6);
  jit_tls->class_cast_from = 0B;
  <D.24271>:
  if (obj == 0B) goto <D.24273>; else goto <D.24274>;
  <D.24273>:
  D.24275 = 0B;
  return D.24275;
  <D.24274>:
  cached_vtable = *cache;
  obj_vtable = obj->vtable;
  if (cached_vtable == obj_vtable) goto <D.24276>; else goto <D.24277>;
  <D.24276>:
  D.24275 = obj;
  return D.24275;
  <D.24277>:
  D.24278 = mono_object_isinst (obj, klass);
  if (D.24278 != 0B) goto <D.24279>; else goto <D.24280>;
  <D.24279>:
  *cache = obj_vtable;
  D.24275 = obj;
  return D.24275;
  <D.24280>:
  D.24281 = mini_get_debug_options ();
  D.24282 = D.24281->better_cast_details;
  if (D.24282 != 0) goto <D.24283>; else goto <D.24284>;
  <D.24283>:
  D.24285 = obj->vtable;
  D.24286 = D.24285->klass;
  jit_tls->class_cast_from = D.24286;
  jit_tls->class_cast_to = klass;
  <D.24284>:
  D.24287 = mono_defaults.corlib;
  D.24288 = mono_exception_from_name (D.24287, "System", "InvalidCastException");
  mono_raise_exception (D.24288);
  D.24275 = 0B;
  return D.24275;
}


mono_object_isinst_with_cache (struct MonoObject * obj, struct MonoClass * klass, void * * cache)
{
  struct MonoObject * D.24292;
  void * D.24293;
  struct MonoVTable * D.24294;
  long unsigned int D.24295;
  struct MonoObject * iftmp.7;
  long unsigned int D.24299;
  struct MonoObject * D.24303;
  void * obj_vtable.8;
  long unsigned int D.24307;
  void * D.24308;
  size_t cached_vtable;
  size_t obj_vtable;

  if (obj == 0B) goto <D.24290>; else goto <D.24291>;
  <D.24290>:
  D.24292 = 0B;
  return D.24292;
  <D.24291>:
  D.24293 = *cache;
  cached_vtable = (size_t) D.24293;
  D.24294 = obj->vtable;
  obj_vtable = (size_t) D.24294;
  D.24295 = cached_vtable & 18446744073709551614;
  if (D.24295 == obj_vtable) goto <D.24296>; else goto <D.24297>;
  <D.24296>:
  D.24299 = cached_vtable & 1;
  if (D.24299 == 0) goto <D.24300>; else goto <D.24301>;
  <D.24300>:
  iftmp.7 = obj;
  goto <D.24302>;
  <D.24301>:
  iftmp.7 = 0B;
  <D.24302>:
  D.24292 = iftmp.7;
  return D.24292;
  <D.24297>:
  D.24303 = mono_object_isinst (obj, klass);
  if (D.24303 != 0B) goto <D.24304>; else goto <D.24305>;
  <D.24304>:
  obj_vtable.8 = (void *) obj_vtable;
  *cache = obj_vtable.8;
  D.24292 = obj;
  return D.24292;
  <D.24305>:
  D.24307 = obj_vtable | 1;
  D.24308 = (void *) D.24307;
  *cache = D.24308;
  D.24292 = 0B;
  return D.24292;
}


__attribute__((visibility ("hidden")))
mono_get_native_calli_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, void * func)
{
  short unsigned int D.24310;
  int D.24311;
  int D.24312;
  long unsigned int D.24313;
  long unsigned int D.24314;
  void * D.24315;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct MonoMethod * m;

  try
    {
      D.24310 = sig->param_count;
      D.24311 = (int) D.24310;
      D.24312 = D.24311 + 1;
      D.24313 = (long unsigned int) D.24312;
      D.24314 = D.24313 * 8;
      mspecs = monoeg_malloc0 (D.24314);
      memset (&piinfo, 0, 56);
      m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
      D.24315 = mono_compile_method (m);
      return D.24315;
    }
  finally
    {
      piinfo = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_gsharedvt_constrained_call (void * mp, struct MonoMethod * cmethod, struct MonoClass * klass, gboolean deref_arg, void * * args)
{
  void * D.24322;
  void * D.24323;
  long unsigned int D.24324;
  long unsigned int D.24325;
  void * this_arg.9;
  struct MonoObject * D.24329;
  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.24318>; else goto <D.24319>;
      <D.24318>:
      if (deref_arg != 0) goto <D.24320>; else goto <D.24321>;
      <D.24320>:
      D.24322 = *args;
      D.24323 = MEM[(void * *)D.24322];
      new_args[0] = D.24323;
      args = &new_args;
      <D.24321>:
      <D.24319>:
      D.24324 = BIT_FIELD_REF <*m, 64, 256>;
      D.24325 = D.24324 & 4467570830351532032;
      if (D.24325 == 864691128455135232) goto <D.24326>; else goto <D.24327>;
      <D.24326>:
      args = &new_args;
      this_arg.9 = this_arg;
      *args = this_arg.9;
      this_arg = 0B;
      <D.24327>:
      this_arg.9 = this_arg;
      D.24329 = mono_runtime_invoke (m, this_arg.9, args, 0B);
      return D.24329;
    }
  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.24332;
  unsigned int D.24333;
  struct MonoException * D.24336;
  struct MonoMethodSignature * D.24337;
  long unsigned int D.24338;
  long unsigned int D.24339;
  struct MonoMethod * * D.24343;
  _Bool D.24344;
  long int D.24345;
  long int D.24346;
  struct MonoClass * D.24349;
  unsigned int D.24350;
  unsigned int D.24351;
  _Bool D.24354;
  long int D.24355;
  long int D.24356;
  long unsigned int D.24359;
  long unsigned int D.24360;
  struct MonoMethod * * D.24361;
  long unsigned int D.24365;
  long unsigned int D.24366;
  struct MonoClass * D.24368;
  struct MonoClass * D.24369;
  struct MonoClass * D.24371;
  struct MonoClass * D.24372;
  struct MonoDomain * D.24374;
  struct MonoObject * D.24375;
  void * D.24379;
  struct MonoMethod * D.24380;
  struct MonoMethod * m;
  int vt_slot;

  D.24332 = klass->flags;
  D.24333 = D.24332 & 32;
  if (D.24333 != 0) goto <D.24334>; else goto <D.24335>;
  <D.24334>:
  D.24336 = mono_get_exception_execution_engine ("Not yet supported.");
  mono_raise_exception (D.24336);
  <D.24335>:
  D.24337 = mono_method_signature (cmethod);
  D.24338 = BIT_FIELD_REF <*D.24337, 64, 64>;
  D.24339 = D.24338 & 128;
  if (D.24339 != 0) goto <D.24340>; else goto <D.24341>;
  <D.24340>:
  m = mono_marshal_get_native_wrapper (cmethod, 1, 0);
  goto <D.24342>;
  <D.24341>:
  mono_class_setup_vtable (klass);
  D.24343 = klass->vtable;
  D.24344 = D.24343 == 0B;
  D.24345 = (long int) D.24344;
  D.24346 = __builtin_expect (D.24345, 0);
  if (D.24346 != 0) goto <D.24347>; else goto <D.24348>;
  <D.24347>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1180, "klass->vtable");
  <D.24348>:
  vt_slot = mono_method_get_vtable_slot (cmethod);
  D.24349 = cmethod->klass;
  D.24350 = D.24349->flags;
  D.24351 = D.24350 & 32;
  if (D.24351 != 0) goto <D.24352>; else goto <D.24353>;
  <D.24352>:
  {
    int iface_offset;

    D.24349 = cmethod->klass;
    iface_offset = mono_class_interface_offset (klass, D.24349);
    D.24354 = iface_offset == -1;
    D.24355 = (long int) D.24354;
    D.24356 = __builtin_expect (D.24355, 0);
    if (D.24356 != 0) goto <D.24357>; else goto <D.24358>;
    <D.24357>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "jit-icalls.c", 1186, "iface_offset != -1");
    <D.24358>:
    vt_slot = vt_slot + iface_offset;
  }
  <D.24353>:
  D.24343 = klass->vtable;
  D.24359 = (long unsigned int) vt_slot;
  D.24360 = D.24359 * 8;
  D.24361 = D.24343 + D.24360;
  m = *D.24361;
  <D.24342>:
  D.24365 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24366 = D.24365 & 1152921504606846976;
  if (D.24366 != 0) goto <D.24367>; else goto <D.24362>;
  <D.24367>:
  D.24368 = m->klass;
  D.24369 = mono_defaults.object_class;
  if (D.24368 == D.24369) goto <D.24363>; else goto <D.24370>;
  <D.24370>:
  D.24368 = m->klass;
  D.24371 = mono_defaults.enum_class;
  D.24372 = D.24371->parent;
  if (D.24368 == D.24372) goto <D.24363>; else goto <D.24373>;
  <D.24373>:
  D.24368 = m->klass;
  D.24371 = mono_defaults.enum_class;
  if (D.24368 == D.24371) goto <D.24363>; else goto <D.24362>;
  <D.24363>:
  D.24374 = mono_domain_get ();
  D.24375 = mono_value_box (D.24374, klass, mp);
  *this_arg = D.24375;
  goto <D.24364>;
  <D.24362>:
  D.24365 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24366 = D.24365 & 1152921504606846976;
  if (D.24366 != 0) goto <D.24376>; else goto <D.24377>;
  <D.24376>:
  *this_arg = mp;
  goto <D.24378>;
  <D.24377>:
  D.24379 = MEM[(void * *)mp];
  *this_arg = D.24379;
  <D.24378>:
  <D.24364>:
  D.24380 = m;
  return D.24380;
}


__attribute__((visibility ("hidden")))
mono_gsharedvt_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  long unsigned int D.24382;
  long unsigned int D.24383;
  struct MonoObject * D.24387;

  D.24382 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24383 = D.24382 & 1152921504606846976;
  if (D.24383 != 0) goto <D.24384>; else goto <D.24385>;
  <D.24384>:
  mono_value_copy (dest, src, klass);
  goto <D.24386>;
  <D.24385>:
  D.24387 = MEM[(struct MonoObject * *)src];
  mono_gc_wbarrier_generic_store (dest, D.24387);
  <D.24386>:
}