mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.26998;
  unsigned char * D.26999;
  unsigned int D.27000;
  long unsigned int D.27001;

  D.26999 = cfg->native_code;
  D.27000 = cfg->code_size;
  D.27001 = (long unsigned int) D.27000;
  D.26998 = monoeg_realloc (D.26999, D.27001);
  return D.26998;
}


__attribute__((visibility ("hidden")))
mono_running_on_valgrind ()
{
  volatile long long unsigned int D.25097;
  unsigned int D.27003;
  gboolean D.27006;

  {
    volatile long long unsigned int _zzq_args[6];
    volatile long long unsigned int _zzq_result;

    _zzq_args[0] = 4097;
    _zzq_args[1] = 0;
    _zzq_args[2] = 0;
    _zzq_args[3] = 0;
    _zzq_args[4] = 0;
    _zzq_args[5] = 0;
    __asm__ __volatile__("lgr 2,%1
	lgr 3,%2
	lr 15,15
	lr 1,1
	lr 2,2
	lr 3,3
	lr 2,2
	lgr %0, 3
	" : "=d" _zzq_result : "a" &_zzq_args[0], "0" 0 : "memory", "3", "2", "cc");
    D.25097 = _zzq_result;
  }
  D.27003 = (unsigned int) D.25097;
  if (D.27003 != 0) goto <D.27004>; else goto <D.27005>;
  <D.27004>:
  D.27006 = 1;
  return D.27006;
  <D.27005>:
  D.27006 = 0;
  return D.27006;
}


__attribute__((__unused__))
mono_pmip (void * ip)
{
  char * D.27008;

  D.27008 = get_method_from_ip (ip);
  return D.27008;
}


__attribute__((__unused__))
get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.27014;
  _Bool D.27017;
  long int D.27018;
  long int D.27019;
  void * D.27022;
  struct GHashTable * D.27023;
  _Bool D.27026;
  long int D.27027;
  long int D.27028;
  struct MonoMethod * D.27031;
  char * D.27034;
  struct MonoMethod * D.27035;
  struct MonoMethod * D.27036;
  long int ip.0;
  void * D.27038;
  long int D.27039;
  long int D.27040;
  unsigned int D.27041;
  int D.27042;
  int D.27043;
  sizetype D.27044;
  char * D.27045;
  char * D.27046;
  struct MonoJitInfo * ji;
  char * method;
  char * res;
  struct MonoDomain * domain;
  struct MonoDebugSourceLocation * location;
  struct FindTrampUserData user_data;

  try
    {
      domain = mono_domain_get ();
      if (domain == 0B) goto <D.27010>; else goto <D.27011>;
      <D.27010>:
      domain = mono_get_root_domain ();
      <D.27011>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.27012>; else goto <D.27013>;
      <D.27012>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.27014 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27014);
        if (ret != 0) goto <D.27015>; else goto <D.27016>;
        <D.27015>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27016>:
        D.27017 = ret != 0;
        D.27018 = (long int) D.27017;
        D.27019 = __builtin_expect (D.27018, 0);
        if (D.27019 != 0) goto <D.27020>; else goto <D.27021>;
        <D.27020>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 305, "ret == 0");
        <D.27021>:
      }
      D.27022 = domain->runtime_info;
      D.27023 = MEM[(struct MonoJitDomainInfo *)D.27022].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.27023, find_tramp, &user_data);
      {
        int ret;

        D.27014 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27014);
        if (ret != 0) goto <D.27024>; else goto <D.27025>;
        <D.27024>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27025>:
        D.27026 = ret != 0;
        D.27027 = (long int) D.27026;
        D.27028 = __builtin_expect (D.27027, 0);
        if (D.27028 != 0) goto <D.27029>; else goto <D.27030>;
        <D.27029>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 307, "ret == 0");
        <D.27030>:
      }
      D.27031 = user_data.method;
      if (D.27031 != 0B) goto <D.27032>; else goto <D.27033>;
      <D.27032>:
      {
        char * mname;

        D.27031 = user_data.method;
        mname = mono_method_full_name (D.27031, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.27034 = res;
        return D.27034;
      }
      <D.27033>:
      D.27034 = 0B;
      return D.27034;
      <D.27013>:
      D.27035 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27035, 1);
      D.27036 = jinfo_get_method (ji);
      ip.0 = (long int) ip;
      D.27038 = ji->code_start;
      D.27039 = (long int) D.27038;
      D.27040 = ip.0 - D.27039;
      D.27041 = (unsigned int) D.27040;
      location = mono_debug_lookup_source_location (D.27036, D.27041, domain);
      ip.0 = (long int) ip;
      D.27038 = ji->code_start;
      D.27039 = (long int) D.27038;
      D.27040 = ip.0 - D.27039;
      D.27042 = (int) D.27040;
      D.27038 = ji->code_start;
      D.27038 = ji->code_start;
      D.27043 = ji->code_size;
      D.27044 = (sizetype) D.27043;
      D.27045 = D.27038 + D.27044;
      D.27046 = domain->friendly_name;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.27042, D.27038, D.27045, domain, D.27046);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.27034 = res;
      return D.27034;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_tramp (void * key, void * value, void * user_data)
{
  void * D.27049;
  struct FindTrampUserData * ud;

  ud = user_data;
  D.27049 = ud->ip;
  if (D.27049 == value) goto <D.27050>; else goto <D.27051>;
  <D.27050>:
  ud->method = key;
  <D.27051>:
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.27052;

  D.27052 = mono_jit_info_get_method (ji);
  return D.27052;
}


__attribute__((used))
mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.27057;
  _Bool D.27060;
  long int D.27061;
  long int D.27062;
  void * D.27065;
  struct GHashTable * D.27066;
  _Bool D.27069;
  long int D.27070;
  long int D.27071;
  struct MonoMethod * D.27074;
  guint8 * D.27077;
  unsigned int D.27080;
  sizetype D.27081;
  guint8 * D.27082;
  long int ip.2;
  long int D.27086;
  long int D.27087;
  int D.27088;
  char * D.27089;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.27091;
  struct MonoMethod * D.27092;
  void * D.27093;
  long int D.27094;
  long int D.27095;
  unsigned int D.27096;
  struct MonoDomain * target_domain.4;
  gboolean * D.27103;
  gboolean * D.27105;
  int D.27106;
  int D.27107;
  sizetype D.27108;
  char * D.27109;
  char * D.27110;
  char * D.27113;
  unsigned int D.27114;
  struct MonoJitInfo * ji;
  char * method;
  struct MonoDebugSourceLocation * source;
  struct MonoDomain * domain;
  struct MonoDomain * target_domain;
  struct FindTrampUserData user_data;
  struct MonoGenericSharingContext * gsctx;
  const char * shared_type;
  struct GSList * l;

  try
    {
      domain = mono_domain_get ();
      target_domain.1 = mono_domain_get ();
      target_domain = target_domain.1;
      ji = mini_jit_info_table_find (domain, ip, &target_domain);
      if (ji == 0B) goto <D.27055>; else goto <D.27056>;
      <D.27055>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.27057 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27057);
        if (ret != 0) goto <D.27058>; else goto <D.27059>;
        <D.27058>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27059>:
        D.27060 = ret != 0;
        D.27061 = (long int) D.27060;
        D.27062 = __builtin_expect (D.27061, 0);
        if (D.27062 != 0) goto <D.27063>; else goto <D.27064>;
        <D.27063>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.27064>:
      }
      D.27065 = domain->runtime_info;
      D.27066 = MEM[(struct MonoJitDomainInfo *)D.27065].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.27066, find_tramp, &user_data);
      {
        int ret;

        D.27057 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27057);
        if (ret != 0) goto <D.27067>; else goto <D.27068>;
        <D.27067>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27068>:
        D.27069 = ret != 0;
        D.27070 = (long int) D.27069;
        D.27071 = __builtin_expect (D.27070, 0);
        if (D.27071 != 0) goto <D.27072>; else goto <D.27073>;
        <D.27072>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.27073>:
      }
      D.27074 = user_data.method;
      if (D.27074 != 0B) goto <D.27075>; else goto <D.27076>;
      <D.27075>:
      {
        char * mname;

        D.27074 = user_data.method;
        mname = mono_method_full_name (D.27074, 1);
        printf ("IP %p is a JIT trampoline for %s\n", ip, mname);
        monoeg_g_free (mname);
        return;
      }
      <D.27076>:
      l = tramp_infos;
      goto <D.25145>;
      <D.25144>:
      {
        struct MonoTrampInfo * tinfo;

        tinfo = l->data;
        D.27077 = tinfo->code;
        if (D.27077 <= ip) goto <D.27078>; else goto <D.27079>;
        <D.27078>:
        D.27077 = tinfo->code;
        D.27080 = tinfo->code_size;
        D.27081 = (sizetype) D.27080;
        D.27082 = D.27077 + D.27081;
        if (D.27082 >= ip) goto <D.27083>; else goto <D.27084>;
        <D.27083>:
        ip.2 = (long int) ip;
        D.27077 = tinfo->code;
        D.27086 = (long int) D.27077;
        D.27087 = ip.2 - D.27086;
        D.27088 = (int) D.27087;
        D.27089 = tinfo->name;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.27088, D.27089);
        return;
        <D.27084>:
        <D.27079>:
      }
      l = l->next;
      <D.25145>:
      if (l != 0B) goto <D.25144>; else goto <D.25146>;
      <D.25146>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.27056>:
      D.27091 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27091, 1);
      D.27092 = jinfo_get_method (ji);
      ip.2 = (long int) ip;
      D.27093 = ji->code_start;
      D.27094 = (long int) D.27093;
      D.27095 = ip.2 - D.27094;
      D.27096 = (unsigned int) D.27095;
      target_domain.4 = target_domain;
      source = mono_debug_lookup_source_location (D.27092, D.27096, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.27098>; else goto <D.27099>;
      <D.27098>:
      D.27103 = gsctx->var_is_vt;
      if (D.27103 != 0B) goto <D.27100>; else goto <D.27104>;
      <D.27104>:
      D.27105 = gsctx->mvar_is_vt;
      if (D.27105 != 0B) goto <D.27100>; else goto <D.27101>;
      <D.27100>:
      shared_type = "gsharedvt ";
      goto <D.27102>;
      <D.27101>:
      shared_type = "gshared ";
      <D.27102>:
      <D.27099>:
      ip.2 = (long int) ip;
      D.27093 = ji->code_start;
      D.27094 = (long int) D.27093;
      D.27095 = ip.2 - D.27094;
      D.27106 = (int) D.27095;
      D.27093 = ji->code_start;
      D.27093 = ji->code_start;
      D.27107 = ji->code_size;
      D.27108 = (sizetype) D.27107;
      D.27109 = D.27093 + D.27108;
      target_domain.4 = target_domain;
      target_domain.4 = target_domain;
      D.27110 = target_domain.4->friendly_name;
      monoeg_g_print ("IP %p at offset 0x%x of %smethod %s (%p %p)[domain %p - %s]\n", ip, D.27106, shared_type, method, D.27093, D.27109, target_domain.4, D.27110);
      if (source != 0B) goto <D.27111>; else goto <D.27112>;
      <D.27111>:
      D.27113 = source->source_file;
      D.27114 = source->row;
      monoeg_g_print ("%s:%d\n", D.27113, D.27114);
      <D.27112>:
      stdout.3 = stdout;
      fflush (stdout.3);
      mono_debug_free_source_location (source);
      monoeg_g_free (method);
    }
  finally
    {
      target_domain = {CLOBBER};
      user_data = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.27118;

  D.27118 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.27118;
}


__attribute__((visibility ("hidden")))
mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  gboolean D.27123;
  long unsigned int D.27124;
  long unsigned int D.27125;
  long unsigned int D.27128;
  long unsigned int D.27129;
  struct MonoClass * D.27132;
  struct MonoClass * D.27133;
  const char * D.27136;
  char * D.27137;
  struct MonoMethod * cmethod;

  if (caller == 0B) goto <D.27120>; else goto <D.27122>;
  <D.27122>:
  if (callee == 0B) goto <D.27120>; else goto <D.27121>;
  <D.27120>:
  D.27123 = 0;
  return D.27123;
  <D.27121>:
  D.27124 = BIT_FIELD_REF <*caller, 64, 256>;
  D.27125 = D.27124 & 281474976710656;
  if (D.27125 != 0) goto <D.27126>; else goto <D.27127>;
  <D.27126>:
  D.27128 = BIT_FIELD_REF <*callee, 64, 256>;
  D.27129 = D.27128 & 281474976710656;
  if (D.27129 == 0) goto <D.27130>; else goto <D.27131>;
  <D.27130>:
  D.27123 = 0;
  return D.27123;
  <D.27131>:
  <D.27127>:
  cmethod = jinfo_get_method (caller);
  D.27132 = cmethod->klass;
  D.27133 = mono_defaults.appdomain_class;
  if (D.27132 == D.27133) goto <D.27134>; else goto <D.27135>;
  <D.27134>:
  D.27136 = cmethod->name;
  D.27137 = strstr (D.27136, "InvokeInDomain");
  if (D.27137 != 0B) goto <D.27138>; else goto <D.27139>;
  <D.27138>:
  D.27123 = 0;
  return D.27123;
  <D.27139>:
  <D.27135>:
  D.27123 = 1;
  return D.27123;
}


__attribute__((visibility ("hidden")))
mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * D.27147;
  void * D.27148;
  _Bool D.27151;
  long int D.27152;
  long int D.27153;
  _Bool D.27158;
  long int D.27159;
  long int D.27160;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.27142>; else goto <D.27143>;
  <D.27142>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.25156>:
  goto <D.25156>;
  <D.27143>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.27145>; else goto <D.27146>;
  <D.27145>:
  D.27147 = mono_code_manager_new ();
  global_codeman = D.27147;
  global_codeman.6 = global_codeman;
  D.27148 = mono_code_manager_reserve (global_codeman.6, size);
  return D.27148;
  <D.27146>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27149>; else goto <D.27150>;
    <D.27149>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27150>:
    D.27151 = ret != 0;
    D.27152 = (long int) D.27151;
    D.27153 = __builtin_expect (D.27152, 0);
    if (D.27153 != 0) goto <D.27154>; else goto <D.27155>;
    <D.27154>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.27155>:
  }
  global_codeman.6 = global_codeman;
  ptr = mono_code_manager_reserve (global_codeman.6, size);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27156>; else goto <D.27157>;
    <D.27156>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27157>:
    D.27158 = ret != 0;
    D.27159 = (long int) D.27158;
    D.27160 = __builtin_expect (D.27159, 0);
    if (D.27160 != 0) goto <D.27161>; else goto <D.27162>;
    <D.27161>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.27162>:
  }
  D.27148 = ptr;
  return D.27148;
}


__attribute__((visibility ("hidden")))
nacl_global_codeman_get_dest (void * data)
{
  void * D.27164;

  D.27164 = data;
  return D.27164;
}


__attribute__((visibility ("hidden")))
mono_global_codeman_commit (void * data, int size, int newsize)
{

}


__attribute__((visibility ("hidden")))
nacl_global_codeman_validate (guint8 * * buf_base, int buf_size, guint8 * * code_end)
{

}


__attribute__((visibility ("hidden")))
mono_create_unwind_op (int when, int tag, int reg, int val)
{
  unsigned char D.27166;
  short unsigned int D.27167;
  unsigned int when.7;
  struct MonoUnwindOp * D.27169;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.27166 = (unsigned char) tag;
  op->op = D.27166;
  D.27167 = (short unsigned int) reg;
  op->reg = D.27167;
  op->val = val;
  when.7 = (unsigned int) when;
  op->when = when.7;
  D.27169 = op;
  return D.27169;
}


__attribute__((visibility ("hidden")))
mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.27171;
  unsigned char D.27172;
  short unsigned int D.27173;
  unsigned int when.8;
  struct GSList * D.27175;
  struct GSList * D.27176;
  unsigned int D.27177;
  const char * D.27180;
  const char * D.27181;
  const char * D.27182;
  int D.27183;
  struct MonoUnwindOp * op;

  D.27171 = cfg->mempool;
  op = mono_mempool_alloc0 (D.27171, 12);
  D.27172 = (unsigned char) tag;
  op->op = D.27172;
  D.27173 = (short unsigned int) reg;
  op->reg = D.27173;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.27171 = cfg->mempool;
  D.27175 = cfg->unwind_ops;
  D.27176 = g_slist_append_mempool (D.27171, D.27175, op);
  cfg->unwind_ops = D.27176;
  D.27177 = cfg->verbose_level;
  if (D.27177 > 1) goto <D.27178>; else goto <D.27179>;
  <D.27178>:
  switch (tag) <default: <D.27184>, case 12: <D.25187>, case 13: <D.25189>, case 14: <D.25190>, case 128: <D.25191>>
  <D.25187>:
  D.27180 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.27180, val);
  goto <D.25188>;
  <D.25189>:
  D.27181 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.27181);
  goto <D.25188>;
  <D.25190>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.25188>;
  <D.25191>:
  D.27182 = mono_arch_regname (reg);
  D.27183 = -val;
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.27182, D.27183);
  goto <D.25188>;
  <D.27184>:
  <D.25188>:
  <D.27179>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.27187;
  struct GSList * D.27188;
  struct GSList * new_list;
  struct GSList * last;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.27185>; else goto <D.27186>;
  <D.27185>:
  last = list;
  goto <D.14479>;
  <D.14478>:
  last = last->next;
  <D.14479>:
  D.27187 = last->next;
  if (D.27187 != 0B) goto <D.14478>; else goto <D.14480>;
  <D.14480>:
  last->next = new_list;
  D.27188 = list;
  return D.27188;
  <D.27186>:
  D.27188 = new_list;
  return D.27188;
}


__attribute__((visibility ("hidden")))
mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.27190;
  int D.27191;
  struct MonoGenericContext * D.27194;
  struct MonoJumpInfoToken * D.27195;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 32);
  res->image = image;
  res->token = token;
  D.27190 = context != 0B;
  D.27191 = (int) D.27190;
  res->has_context = D.27191;
  if (context != 0B) goto <D.27192>; else goto <D.27193>;
  <D.27192>:
  D.27194 = &res->context;
  memcpy (D.27194, context, 16);
  <D.27193>:
  D.27195 = res;
  return D.27195;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.27197;
  long unsigned int D.27198;

  D.27198 = __builtin_object_size (__dest, 0);
  D.27197 = __builtin___memcpy_chk (__dest, __src, __len, D.27198);
  return D.27197;
}


__attribute__((visibility ("hidden")))
mono_jump_info_token_new (struct MonoMemPool * mp, struct MonoImage * image, guint32 token)
{
  struct MonoJumpInfoToken * D.27200;

  D.27200 = mono_jump_info_token_new2 (mp, image, token, 0B);
  return D.27200;
}


__attribute__((visibility ("hidden")))
mono_tramp_info_create (const char * name, guint8 * code, guint32 code_size, struct MonoJumpInfo * ji, struct GSList * unwind_ops)
{
  gchar * D.27202;
  struct MonoTrampInfo * D.27203;
  struct MonoTrampInfo * info;

  info = monoeg_malloc0 (56);
  D.27202 = monoeg_strdup (name);
  info->name = D.27202;
  info->code = code;
  info->code_size = code_size;
  info->ji = ji;
  info->unwind_ops = unwind_ops;
  D.27203 = info;
  return D.27203;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.27207;

  if (str != 0B) goto <D.27205>; else goto <D.27206>;
  <D.27205>:
  D.27207 = __strdup (str);
  return D.27207;
  <D.27206>:
  D.27207 = 0B;
  return D.27207;
}


__attribute__((visibility ("hidden")))
mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.27209;
  void * D.27210;
  struct GSList * D.27211;
  struct GSList * l;

  D.27209 = info->name;
  monoeg_g_free (D.27209);
  l = info->unwind_ops;
  goto <D.25217>;
  <D.25216>:
  D.27210 = l->data;
  monoeg_g_free (D.27210);
  l = l->next;
  <D.25217>:
  if (l != 0B) goto <D.25216>; else goto <D.25218>;
  <D.25218>:
  D.27211 = info->unwind_ops;
  monoeg_g_slist_free (D.27211);
  monoeg_g_free (info);
}


__attribute__((visibility ("hidden")))
mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.27214;
  unsigned int D.27215;
  char * D.27216;
  gchar * D.27217;
  _Bool D.27220;
  long int D.27221;
  long int D.27222;
  struct GSList * tramp_infos.9;
  struct GSList * D.27226;
  _Bool D.27229;
  long int D.27230;
  long int D.27231;
  int D.27234;
  int D.27237;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.27212>; else goto <D.27213>;
  <D.27212>:
  return;
  <D.27213>:
  copy = monoeg_malloc0 (56);
  D.27214 = info->code;
  copy->code = D.27214;
  D.27215 = info->code_size;
  copy->code_size = D.27215;
  D.27216 = info->name;
  D.27217 = monoeg_strdup (D.27216);
  copy->name = D.27217;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27218>; else goto <D.27219>;
    <D.27218>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27219>:
    D.27220 = ret != 0;
    D.27221 = (long int) D.27220;
    D.27222 = __builtin_expect (D.27221, 0);
    if (D.27222 != 0) goto <D.27223>; else goto <D.27224>;
    <D.27223>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.27224>:
  }
  tramp_infos.9 = tramp_infos;
  D.27226 = monoeg_g_slist_prepend (tramp_infos.9, copy);
  tramp_infos = D.27226;
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27227>; else goto <D.27228>;
    <D.27227>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27228>:
    D.27229 = ret != 0;
    D.27230 = (long int) D.27229;
    D.27231 = __builtin_expect (D.27230, 0);
    if (D.27231 != 0) goto <D.27232>; else goto <D.27233>;
    <D.27232>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.27233>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.27234 = mono_jit_map_is_enabled ();
  if (D.27234 != 0) goto <D.27235>; else goto <D.27236>;
  <D.27235>:
  D.27214 = info->code;
  D.27215 = info->code_size;
  D.27237 = (int) D.27215;
  D.27216 = info->name;
  mono_emit_jit_tramp (D.27214, D.27237, D.27216);
  <D.27236>:
  mono_tramp_info_free (info);
}


__attribute__((__unused__, visibility ("hidden")))
mono_debug_count ()
{
  int count.10;
  int count.11;
  const gchar * D.27241;
  gboolean D.27244;
  const gchar * D.27245;
  int D.27246;
  const gchar * D.27249;
  int D.27250;
  static int count = 0;

  count.10 = count;
  count.11 = count.10 + 1;
  count = count.11;
  D.27241 = monoeg_g_getenv ("COUNT");
  if (D.27241 == 0B) goto <D.27242>; else goto <D.27243>;
  <D.27242>:
  D.27244 = 1;
  return D.27244;
  <D.27243>:
  D.27245 = monoeg_g_getenv ("COUNT");
  D.27246 = atoi (D.27245);
  count.10 = count;
  if (D.27246 == count.10) goto <D.27247>; else goto <D.27248>;
  <D.27247>:
  break_count ();
  <D.27248>:
  D.27249 = monoeg_g_getenv ("COUNT");
  D.27250 = atoi (D.27249);
  count.10 = count;
  if (D.27250 < count.10) goto <D.27251>; else goto <D.27252>;
  <D.27251>:
  D.27244 = 0;
  return D.27244;
  <D.27252>:
  D.27244 = 1;
  return D.27244;
}


__attribute__((__unused__))
break_count ()
{

}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.27254;
  long int D.27255;

  D.27255 = strtol (__nptr, 0B, 10);
  D.27254 = (int) D.27255;
  return D.27254;
}


__attribute__((visibility ("hidden")))
mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.27257;
  long unsigned int D.27258;
  long unsigned int D.27259;
  struct MonoBasicBlock * * D.27260;
  struct MonoBasicBlock * D.27261;
  short int D.27264;
  int D.27265;
  int pos.12;
  long unsigned int D.27271;
  long unsigned int D.27272;
  struct MonoBasicBlock * * D.27273;
  int D.27274;
  _Bool D.27275;
  long int D.27276;
  long int D.27277;
  short int D.27280;
  unsigned short D.27281;
  unsigned short D.27282;
  short int D.27283;
  struct MonoBasicBlock * * D.27284;
  struct MonoBasicBlock * * D.27285;
  struct MonoBasicBlock * D.27286;
  short int D.27289;
  int D.27290;
  int pos.13;
  long unsigned int D.27296;
  long unsigned int D.27297;
  struct MonoBasicBlock * * D.27298;
  int D.27299;
  _Bool D.27300;
  long int D.27301;
  long int D.27302;
  short int D.27305;
  unsigned short D.27306;
  unsigned short D.27307;
  short int D.27308;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.25242>;
  <D.25241>:
  D.27257 = from->out_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27260 = D.27257 + D.27259;
  D.27261 = *D.27260;
  if (D.27261 == to) goto <D.27262>; else goto <D.27263>;
  <D.27262>:
  found = 1;
  goto <D.25240>;
  <D.27263>:
  i = i + 1;
  <D.25242>:
  D.27264 = from->out_count;
  D.27265 = (int) D.27264;
  if (D.27265 > i) goto <D.25241>; else goto <D.25240>;
  <D.25240>:
  if (found != 0) goto <D.27266>; else goto <D.27267>;
  <D.27266>:
  pos = 0;
  i = 0;
  goto <D.25244>;
  <D.25243>:
  D.27257 = from->out_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27260 = D.27257 + D.27259;
  D.27261 = *D.27260;
  if (D.27261 != to) goto <D.27268>; else goto <D.27269>;
  <D.27268>:
  D.27257 = from->out_bb;
  pos.12 = pos;
  pos = pos.12 + 1;
  D.27271 = (long unsigned int) pos.12;
  D.27272 = D.27271 * 8;
  D.27273 = D.27257 + D.27272;
  D.27257 = from->out_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27260 = D.27257 + D.27259;
  D.27261 = *D.27260;
  *D.27273 = D.27261;
  <D.27269>:
  i = i + 1;
  <D.25244>:
  D.27264 = from->out_count;
  D.27265 = (int) D.27264;
  if (D.27265 > i) goto <D.25243>; else goto <D.25245>;
  <D.25245>:
  D.27264 = from->out_count;
  D.27265 = (int) D.27264;
  D.27274 = D.27265 + -1;
  D.27275 = D.27274 != pos;
  D.27276 = (long int) D.27275;
  D.27277 = __builtin_expect (D.27276, 0);
  if (D.27277 != 0) goto <D.27278>; else goto <D.27279>;
  <D.27278>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.27279>:
  D.27264 = from->out_count;
  D.27280 = D.27264;
  D.27281 = (unsigned short) D.27280;
  D.27282 = D.27281 + 65535;
  D.27283 = (short int) D.27282;
  from->out_count = D.27283;
  <D.27267>:
  found = 0;
  i = 0;
  goto <D.25248>;
  <D.25247>:
  D.27284 = to->in_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27285 = D.27284 + D.27259;
  D.27286 = *D.27285;
  if (D.27286 == from) goto <D.27287>; else goto <D.27288>;
  <D.27287>:
  found = 1;
  goto <D.25246>;
  <D.27288>:
  i = i + 1;
  <D.25248>:
  D.27289 = to->in_count;
  D.27290 = (int) D.27289;
  if (D.27290 > i) goto <D.25247>; else goto <D.25246>;
  <D.25246>:
  if (found != 0) goto <D.27291>; else goto <D.27292>;
  <D.27291>:
  pos = 0;
  i = 0;
  goto <D.25250>;
  <D.25249>:
  D.27284 = to->in_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27285 = D.27284 + D.27259;
  D.27286 = *D.27285;
  if (D.27286 != from) goto <D.27293>; else goto <D.27294>;
  <D.27293>:
  D.27284 = to->in_bb;
  pos.13 = pos;
  pos = pos.13 + 1;
  D.27296 = (long unsigned int) pos.13;
  D.27297 = D.27296 * 8;
  D.27298 = D.27284 + D.27297;
  D.27284 = to->in_bb;
  D.27258 = (long unsigned int) i;
  D.27259 = D.27258 * 8;
  D.27285 = D.27284 + D.27259;
  D.27286 = *D.27285;
  *D.27298 = D.27286;
  <D.27294>:
  i = i + 1;
  <D.25250>:
  D.27289 = to->in_count;
  D.27290 = (int) D.27289;
  if (D.27290 > i) goto <D.25249>; else goto <D.25251>;
  <D.25251>:
  D.27289 = to->in_count;
  D.27290 = (int) D.27289;
  D.27299 = D.27290 + -1;
  D.27300 = D.27299 != pos;
  D.27301 = (long int) D.27300;
  D.27302 = __builtin_expect (D.27301, 0);
  if (D.27302 != 0) goto <D.27303>; else goto <D.27304>;
  <D.27303>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.27304>:
  D.27289 = to->in_count;
  D.27305 = D.27289;
  D.27306 = (unsigned short) D.27305;
  D.27307 = D.27306 + 65535;
  D.27308 = (short int) D.27307;
  to->in_count = D.27308;
  <D.27292>:
}


__attribute__((visibility ("hidden")))
mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.27309;
  long unsigned int D.27310;
  long unsigned int D.27311;
  struct MonoBasicBlock * * D.27312;
  struct MonoBasicBlock * D.27313;
  gboolean D.27316;
  short int D.27317;
  int D.27318;
  int i;

  i = 0;
  goto <D.25258>;
  <D.25257>:
  D.27309 = bb1->out_bb;
  D.27310 = (long unsigned int) i;
  D.27311 = D.27310 * 8;
  D.27312 = D.27309 + D.27311;
  D.27313 = *D.27312;
  if (D.27313 == bb2) goto <D.27314>; else goto <D.27315>;
  <D.27314>:
  D.27316 = 1;
  return D.27316;
  <D.27315>:
  i = i + 1;
  <D.25258>:
  D.27317 = bb1->out_count;
  D.27318 = (int) D.27317;
  if (D.27318 > i) goto <D.25257>; else goto <D.25259>;
  <D.25259>:
  D.27316 = 0;
  return D.27316;
}


__attribute__((visibility ("hidden")))
mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.27320;
  int D.27323;
  int iftmp.14;
  <unnamed-unsigned:15> D.27329;
  int D.27330;
  _Bool D.27331;
  long int D.27332;
  long int D.27333;
  struct MonoExceptionClause * D.27336;
  long unsigned int D.27337;
  long unsigned int D.27338;
  struct MonoExceptionClause * D.27339;
  unsigned int D.27340;
  int D.27341;
  int D.27342;

  D.27320 = region & 240;
  if (D.27320 == 0) goto <D.27321>; else goto <D.27322>;
  <D.27321>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.27323 = region >> 8;
    clause_index = D.27323 + -1;
    if (clause_index < 0) goto <D.27325>; else goto <D.27328>;
    <D.27328>:
    D.27329 = header->num_clauses;
    D.27330 = (int) D.27329;
    if (D.27330 <= clause_index) goto <D.27325>; else goto <D.27326>;
    <D.27325>:
    iftmp.14 = 1;
    goto <D.27327>;
    <D.27326>:
    iftmp.14 = 0;
    <D.27327>:
    D.27331 = iftmp.14 != 0;
    D.27332 = (long int) D.27331;
    D.27333 = __builtin_expect (D.27332, 0);
    if (D.27333 != 0) goto <D.27334>; else goto <D.27335>;
    <D.27334>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.27335>:
    D.27336 = header->clauses;
    D.27337 = (long unsigned int) clause_index;
    D.27338 = D.27337 * 32;
    D.27339 = D.27336 + D.27338;
    D.27340 = D.27339->try_offset;
    D.27341 = (int) D.27340;
    region = mono_find_block_region_notry (cfg, D.27341);
  }
  <D.27322>:
  D.27342 = region;
  return D.27342;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.27344;
  long unsigned int D.27345;
  long unsigned int D.27346;
  unsigned int D.27347;
  unsigned int D.27350;
  unsigned int offset.15;
  unsigned int D.27354;
  int D.27357;
  int D.27358;
  int D.27359;
  unsigned int D.27360;
  unsigned int D.27361;
  unsigned int D.27362;
  unsigned int D.27365;
  unsigned int D.27366;
  unsigned int D.27371;
  unsigned int D.27374;
  unsigned int D.27375;
  <unnamed-unsigned:15> D.27376;
  int D.27377;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.25268>;
  <D.25267>:
  D.27344 = header->clauses;
  D.27345 = (long unsigned int) i;
  D.27346 = D.27345 * 32;
  clause = D.27344 + D.27346;
  D.27347 = clause->flags;
  if (D.27347 == 1) goto <D.27348>; else goto <D.27349>;
  <D.27348>:
  D.27350 = clause->data.filter_offset;
  offset.15 = (unsigned int) offset;
  if (D.27350 <= offset.15) goto <D.27352>; else goto <D.27353>;
  <D.27352>:
  D.27354 = clause->handler_offset;
  offset.15 = (unsigned int) offset;
  if (D.27354 > offset.15) goto <D.27355>; else goto <D.27356>;
  <D.27355>:
  D.27358 = i + 1;
  D.27359 = D.27358 << 8;
  D.27360 = (unsigned int) D.27359;
  D.27347 = clause->flags;
  D.27361 = D.27360 | D.27347;
  D.27362 = D.27361 | 128;
  D.27357 = (int) D.27362;
  return D.27357;
  <D.27356>:
  <D.27353>:
  <D.27349>:
  D.27354 = clause->handler_offset;
  offset.15 = (unsigned int) offset;
  if (D.27354 <= offset.15) goto <D.27363>; else goto <D.27364>;
  <D.27363>:
  D.27354 = clause->handler_offset;
  D.27365 = clause->handler_len;
  D.27366 = D.27354 + D.27365;
  offset.15 = (unsigned int) offset;
  if (D.27366 > offset.15) goto <D.27367>; else goto <D.27368>;
  <D.27367>:
  D.27347 = clause->flags;
  if (D.27347 == 2) goto <D.27369>; else goto <D.27370>;
  <D.27369>:
  D.27358 = i + 1;
  D.27359 = D.27358 << 8;
  D.27360 = (unsigned int) D.27359;
  D.27347 = clause->flags;
  D.27361 = D.27360 | D.27347;
  D.27371 = D.27361 | 16;
  D.27357 = (int) D.27371;
  return D.27357;
  <D.27370>:
  D.27347 = clause->flags;
  if (D.27347 == 4) goto <D.27372>; else goto <D.27373>;
  <D.27372>:
  D.27358 = i + 1;
  D.27359 = D.27358 << 8;
  D.27360 = (unsigned int) D.27359;
  D.27347 = clause->flags;
  D.27361 = D.27360 | D.27347;
  D.27374 = D.27361 | 64;
  D.27357 = (int) D.27374;
  return D.27357;
  <D.27373>:
  D.27358 = i + 1;
  D.27359 = D.27358 << 8;
  D.27360 = (unsigned int) D.27359;
  D.27347 = clause->flags;
  D.27361 = D.27360 | D.27347;
  D.27375 = D.27361 | 32;
  D.27357 = (int) D.27375;
  return D.27357;
  <D.27368>:
  <D.27364>:
  i = i + 1;
  <D.25268>:
  D.27376 = header->num_clauses;
  D.27377 = (int) D.27376;
  if (D.27377 > i) goto <D.25267>; else goto <D.25269>;
  <D.25269>:
  D.27357 = -1;
  return D.27357;
}


__attribute__((visibility ("hidden")))
mono_find_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct MonoInst * D.27379;
  struct GHashTable * D.27380;
  long int D.27381;
  const void * D.27382;

  region = mono_get_block_region_notry (cfg, region);
  D.27380 = cfg->spvars;
  D.27381 = (long int) region;
  D.27382 = (const void *) D.27381;
  D.27379 = monoeg_g_hash_table_lookup (D.27380, D.27382);
  return D.27379;
}


__attribute__((visibility ("hidden")))
mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.27384;
  int D.27387;
  unsigned int D.27389;
  int D.27392;
  unsigned int D.27394;
  int D.27397;
  unsigned int D.27399;
  int D.27402;
  guint32 D.27404;
  static const int reverse_map[10] = {64, 63, 62, 61, 60, 59, 68, 67, 66, 65};
  static const int reverse_fmap[10] = {663, 662, 661, 660, 659, 658, 667, 666, 665, 664};
  static const int reverse_lmap[10] = {556, 555, 554, 553, 552, 551, 560, 559, 558, 557};
  static const int reverse_imap[10] = {653, 652, 651, 650, 649, 648, 657, 656, 655, 654};

  D.27384 = opcode + 4294967237;
  if (D.27384 <= 9) goto <D.27385>; else goto <D.27386>;
  <D.27385>:
  D.27384 = opcode + 4294967237;
  D.27387 = reverse_map[D.27384];
  opcode = (guint32) D.27387;
  goto <D.27388>;
  <D.27386>:
  D.27389 = opcode + 4294966638;
  if (D.27389 <= 9) goto <D.27390>; else goto <D.27391>;
  <D.27390>:
  D.27389 = opcode + 4294966638;
  D.27392 = reverse_fmap[D.27389];
  opcode = (guint32) D.27392;
  goto <D.27393>;
  <D.27391>:
  D.27394 = opcode + 4294966745;
  if (D.27394 <= 9) goto <D.27395>; else goto <D.27396>;
  <D.27395>:
  D.27394 = opcode + 4294966745;
  D.27397 = reverse_lmap[D.27394];
  opcode = (guint32) D.27397;
  goto <D.27398>;
  <D.27396>:
  D.27399 = opcode + 4294966648;
  if (D.27399 <= 9) goto <D.27400>; else goto <D.27401>;
  <D.27400>:
  D.27399 = opcode + 4294966648;
  D.27402 = reverse_imap[D.27399];
  opcode = (guint32) D.27402;
  goto <D.27403>;
  <D.27401>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.27403>:
  <D.27398>:
  <D.27393>:
  <D.27388>:
  D.27404 = opcode;
  return D.27404;
}


__attribute__((visibility ("hidden")))
mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.27406;
  long unsigned int D.27407;
  guint D.27410;
  unsigned char D.27411;
  int D.27412;
  struct MonoClass * D.27413;
  long unsigned int D.27414;
  long unsigned int D.27415;
  struct MonoGenericClass * D.27420;
  struct MonoClass * D.27421;
  int D.27422;
  void handle_enum = <<< error >>>;

  D.27406 = BIT_FIELD_REF <*type, 64, 64>;
  D.27407 = D.27406 & 8589934592;
  if (D.27407 != 0) goto <D.27408>; else goto <D.27409>;
  <D.27408>:
  D.27410 = 374;
  return D.27410;
  <D.27409>:
  type = mini_replace_type (type);
  handle_enum:
  D.27411 = type->type;
  D.27412 = (int) D.27411;
  switch (D.27412) <default: <D.25328>, case 2: <D.25304>, case 3: <D.25307>, case 4: <D.25302>, case 5: <D.25303>, case 6: <D.25305>, case 7: <D.25306>, case 8: <D.25308>, case 9: <D.25309>, case 10: <D.25319>, case 11: <D.25320>, case 12: <D.25321>, case 13: <D.25322>, case 14: <D.25315>, case 15: <D.25312>, case 17: <D.25323>, case 18: <D.25314>, case 19: <D.25326>, case 20: <D.25318>, case 21: <D.25325>, case 22: <D.25324>, case 24: <D.25310>, case 25: <D.25311>, case 27: <D.25313>, case 28: <D.25316>, case 29: <D.25317>, case 30: <D.25327>>
  <D.25302>:
  <D.25303>:
  <D.25304>:
  D.27410 = 375;
  return D.27410;
  <D.25305>:
  <D.25306>:
  <D.25307>:
  D.27410 = 376;
  return D.27410;
  <D.25308>:
  <D.25309>:
  D.27410 = 377;
  return D.27410;
  <D.25310>:
  <D.25311>:
  <D.25312>:
  <D.25313>:
  D.27410 = 374;
  return D.27410;
  <D.25314>:
  <D.25315>:
  <D.25316>:
  <D.25317>:
  <D.25318>:
  D.27410 = 374;
  return D.27410;
  <D.25319>:
  <D.25320>:
  D.27410 = 378;
  return D.27410;
  <D.25321>:
  D.27410 = 379;
  return D.27410;
  <D.25322>:
  D.27410 = 380;
  return D.27410;
  <D.25323>:
  D.27413 = type->data.klass;
  D.27414 = BIT_FIELD_REF <*D.27413, 64, 256>;
  D.27415 = D.27414 & 576460752303423488;
  if (D.27415 != 0) goto <D.27416>; else goto <D.27417>;
  <D.27416>:
  D.27413 = type->data.klass;
  type = mono_class_enum_basetype (D.27413);
  goto handle_enum;
  <D.27417>:
  if (0 != 0) goto <D.27418>; else goto <D.27419>;
  <D.27418>:
  D.27410 = 386;
  return D.27410;
  <D.27419>:
  D.27410 = 387;
  return D.27410;
  <D.25324>:
  D.27410 = 387;
  return D.27410;
  <D.25325>:
  D.27420 = type->data.generic_class;
  D.27421 = D.27420->container_class;
  type = &D.27421->byval_arg;
  goto handle_enum;
  <D.25326>:
  <D.25327>:
  D.27422 = mini_type_var_is_vt (cfg, type);
  if (D.27422 != 0) goto <D.27423>; else goto <D.27424>;
  <D.27423>:
  D.27410 = 387;
  return D.27410;
  <D.27424>:
  D.27410 = 374;
  return D.27410;
  <D.25328>:
  D.27411 = type->type;
  D.27412 = (int) D.27411;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.27412);
  <D.25329>:
  goto <D.25329>;
  D.27410 = 4294967295;
  return D.27410;
}


__attribute__((visibility ("hidden")))
mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.27426;
  long unsigned int D.27427;
  guint D.27430;
  unsigned char D.27431;
  int D.27432;
  int D.27435;
  struct MonoGenericSharingContext * D.27438;
  _Bool D.27439;
  long int D.27440;
  long int D.27441;
  int D.27444;

  D.27426 = BIT_FIELD_REF <*type, 64, 64>;
  D.27427 = D.27426 & 8589934592;
  if (D.27427 != 0) goto <D.27428>; else goto <D.27429>;
  <D.27428>:
  D.27430 = 388;
  return D.27430;
  <D.27429>:
  type = mini_replace_type (type);
  D.27431 = type->type;
  D.27432 = (int) D.27431;
  switch (D.27432) <default: <D.25360>, case 2: <D.25336>, case 3: <D.25339>, case 4: <D.25334>, case 5: <D.25335>, case 6: <D.25337>, case 7: <D.25338>, case 8: <D.25340>, case 9: <D.25341>, case 10: <D.25351>, case 11: <D.25352>, case 12: <D.25353>, case 13: <D.25354>, case 14: <D.25347>, case 15: <D.25344>, case 17: <D.25355>, case 18: <D.25346>, case 19: <D.25358>, case 20: <D.25350>, case 21: <D.25357>, case 22: <D.25356>, case 24: <D.25342>, case 25: <D.25343>, case 27: <D.25345>, case 28: <D.25348>, case 29: <D.25349>, case 30: <D.25359>>
  <D.25334>:
  D.27430 = 389;
  return D.27430;
  <D.25335>:
  <D.25336>:
  D.27430 = 390;
  return D.27430;
  <D.25337>:
  D.27430 = 391;
  return D.27430;
  <D.25338>:
  <D.25339>:
  D.27430 = 392;
  return D.27430;
  <D.25340>:
  D.27430 = 393;
  return D.27430;
  <D.25341>:
  D.27430 = 394;
  return D.27430;
  <D.25342>:
  <D.25343>:
  <D.25344>:
  <D.25345>:
  D.27430 = 388;
  return D.27430;
  <D.25346>:
  <D.25347>:
  <D.25348>:
  <D.25349>:
  <D.25350>:
  D.27430 = 388;
  return D.27430;
  <D.25351>:
  <D.25352>:
  D.27430 = 395;
  return D.27430;
  <D.25353>:
  D.27430 = 396;
  return D.27430;
  <D.25354>:
  D.27430 = 397;
  return D.27430;
  <D.25355>:
  if (0 != 0) goto <D.27433>; else goto <D.27434>;
  <D.27433>:
  D.27430 = 398;
  return D.27430;
  <D.27434>:
  <D.25356>:
  D.27430 = 399;
  return D.27430;
  <D.25357>:
  D.27435 = mono_type_generic_inst_is_valuetype (type);
  if (D.27435 != 0) goto <D.27436>; else goto <D.27437>;
  <D.27436>:
  D.27430 = 399;
  return D.27430;
  <D.27437>:
  D.27430 = 388;
  return D.27430;
  <D.25358>:
  <D.25359>:
  D.27438 = cfg->generic_sharing_context;
  D.27439 = D.27438 == 0B;
  D.27440 = (long int) D.27439;
  D.27441 = __builtin_expect (D.27440, 0);
  if (D.27441 != 0) goto <D.27442>; else goto <D.27443>;
  <D.27442>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.27443>:
  D.27444 = mini_type_var_is_vt (cfg, type);
  if (D.27444 != 0) goto <D.27445>; else goto <D.27446>;
  <D.27445>:
  D.27430 = 399;
  return D.27430;
  <D.27446>:
  D.27430 = 388;
  return D.27430;
  <D.25360>:
  D.27431 = type->type;
  D.27432 = (int) D.27431;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.27432);
  <D.25361>:
  goto <D.25361>;
  D.27430 = 4294967295;
  return D.27430;
}


__attribute__((visibility ("hidden")))
mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27448;
  long unsigned int D.27451;
  long unsigned int D.27452;
  unsigned char D.27457;
  int D.27459;
  guint D.27462;

  type = mini_replace_type (type);
  D.27448 = cfg->generic_sharing_context;
  if (D.27448 != 0B) goto <D.27449>; else goto <D.27450>;
  <D.27449>:
  D.27451 = BIT_FIELD_REF <*type, 64, 64>;
  D.27452 = D.27451 & 8589934592;
  if (D.27452 == 0) goto <D.27453>; else goto <D.27454>;
  <D.27453>:
  D.27457 = type->type;
  if (D.27457 == 19) goto <D.27455>; else goto <D.27458>;
  <D.27458>:
  D.27457 = type->type;
  if (D.27457 == 30) goto <D.27455>; else goto <D.27456>;
  <D.27455>:
  D.27459 = mini_type_var_is_vt (cfg, type);
  if (D.27459 != 0) goto <D.27460>; else goto <D.27461>;
  <D.27460>:
  D.27462 = 129;
  return D.27462;
  <D.27461>:
  D.27462 = 81;
  return D.27462;
  <D.27456>:
  <D.27454>:
  <D.27450>:
  D.27462 = mono_type_to_stind (type);
  return D.27462;
}


__attribute__((visibility ("hidden")))
mono_op_imm_to_op (int opcode)
{
  int D.27464;
  const char * D.27465;

  switch (opcode) <default: <D.25409>, case 323: <D.25406>, case 327: <D.25407>, case 339: <D.25408>, case 429: <D.25373>, case 432: <D.25398>, case 434: <D.25399>, case 436: <D.25379>, case 437: <D.25380>, case 438: <D.25381>, case 538: <D.25375>, case 539: <D.25377>, case 541: <D.25383>, case 542: <D.25385>, case 543: <D.25387>, case 544: <D.25389>, case 545: <D.25391>, case 546: <D.25393>, case 620: <D.25404>, case 622: <D.25405>, case 625: <D.25374>, case 626: <D.25376>, case 627: <D.25378>, case 628: <D.25394>, case 629: <D.25395>, case 630: <D.25397>, case 631: <D.25396>, case 632: <D.25382>, case 633: <D.25384>, case 634: <D.25386>, case 635: <D.25388>, case 636: <D.25390>, case 637: <D.25392>, case 752: <D.25401>, case 754: <D.25403>, case 756: <D.25400>, case 758: <D.25402>>
  <D.25373>:
  D.27464 = 479;
  return D.27464;
  <D.25374>:
  D.27464 = 565;
  return D.27464;
  <D.25375>:
  D.27464 = 479;
  return D.27464;
  <D.25376>:
  D.27464 = 566;
  return D.27464;
  <D.25377>:
  D.27464 = 480;
  return D.27464;
  <D.25378>:
  D.27464 = 567;
  return D.27464;
  <D.25379>:
  D.27464 = 486;
  return D.27464;
  <D.25380>:
  D.27464 = 487;
  return D.27464;
  <D.25381>:
  D.27464 = 488;
  return D.27464;
  <D.25382>:
  D.27464 = 572;
  return D.27464;
  <D.25383>:
  D.27464 = 486;
  return D.27464;
  <D.25384>:
  D.27464 = 573;
  return D.27464;
  <D.25385>:
  D.27464 = 487;
  return D.27464;
  <D.25386>:
  D.27464 = 574;
  return D.27464;
  <D.25387>:
  D.27464 = 488;
  return D.27464;
  <D.25388>:
  D.27464 = 575;
  return D.27464;
  <D.25389>:
  D.27464 = 489;
  return D.27464;
  <D.25390>:
  D.27464 = 576;
  return D.27464;
  <D.25391>:
  D.27464 = 490;
  return D.27464;
  <D.25392>:
  D.27464 = 577;
  return D.27464;
  <D.25393>:
  D.27464 = 491;
  return D.27464;
  <D.25394>:
  D.27464 = 568;
  return D.27464;
  <D.25395>:
  D.27464 = 569;
  return D.27464;
  <D.25396>:
  D.27464 = 571;
  return D.27464;
  <D.25397>:
  D.27464 = 570;
  return D.27464;
  <D.25398>:
  D.27464 = 482;
  return D.27464;
  <D.25399>:
  D.27464 = 484;
  return D.27464;
  <D.25400>:
  D.27464 = 755;
  return D.27464;
  <D.25401>:
  D.27464 = 751;
  return D.27464;
  <D.25402>:
  D.27464 = 757;
  return D.27464;
  <D.25403>:
  D.27464 = 753;
  return D.27464;
  <D.25404>:
  D.27464 = 619;
  return D.27464;
  <D.25405>:
  D.27464 = 621;
  return D.27464;
  <D.25406>:
  D.27464 = 322;
  return D.27464;
  <D.25407>:
  D.27464 = 326;
  return D.27464;
  <D.25408>:
  D.27464 = 338;
  return D.27464;
  <D.25409>:
  D.27465 = mono_inst_name (opcode);
  printf ("%s\n", D.27465);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.27464 = -1;
  return D.27464;
}


__attribute__((visibility ("hidden")))
mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.27467;
  long int D.27468;
  struct MonoInst * D.27469;
  int D.27470;
  int D.27471;
  const unsigned char * D.27472;
  long int D.27473;
  unsigned int D.27474;
  int D.27475;
  short unsigned int D.27476;
  int D.27477;
  int D.27478;
  short unsigned int D.27479;
  int D.27482;
  unsigned int D.27484;
  unsigned int D.27485;
  unsigned int D.27486;
  struct MonoInst * temp;

  D.27467 = cfg->mempool;
  temp = mono_mempool_alloc (D.27467, 80);
  temp->data.op[1].const_val = 0;
  D.27468 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.27468;
  temp->prev = 0B;
  D.27469 = temp->prev;
  temp->next = D.27469;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.27470 = temp->sreg3;
  temp->sreg2 = D.27470;
  D.27471 = temp->sreg2;
  temp->sreg1 = D.27471;
  D.27472 = cfg->ip;
  temp->cil_code = D.27472;
  D.27473 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.27473;
  D.27474 = mono_alloc_ireg (cfg);
  D.27475 = (int) D.27474;
  temp->dreg = D.27475;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.27476 = ins->opcode;
  D.27477 = (int) D.27476;
  D.27478 = mono_op_imm_to_op (D.27477);
  D.27479 = (short unsigned int) D.27478;
  ins->opcode = D.27479;
  D.27476 = ins->opcode;
  if (D.27476 == 338) goto <D.27480>; else goto <D.27481>;
  <D.27480>:
  D.27482 = temp->dreg;
  ins->sreg1 = D.27482;
  goto <D.27483>;
  <D.27481>:
  D.27482 = temp->dreg;
  ins->sreg2 = D.27482;
  <D.27483>:
  D.27484 = cfg->next_vreg;
  D.27485 = bb->max_vreg;
  D.27486 = MAX_EXPR <D.27484, D.27485>;
  bb->max_vreg = D.27486;
}


__attribute__((visibility ("hidden")))
mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.27487;
  int D.27488;
  unsigned int D.27489;
  unsigned int D.27490;
  guint iftmp.16;
  struct MonoInst * * D.27497;
  long unsigned int D.27498;
  long unsigned int D.27499;
  void * D.27500;
  struct MonoMethodVar * D.27501;
  long unsigned int D.27502;
  void * D.27503;
  long unsigned int D.27504;
  long unsigned int D.27505;
  struct MonoMethodVar * D.27506;
  unsigned int orig_count.17;
  unsigned int D.27508;
  long unsigned int D.27509;
  long unsigned int D.27510;
  int D.27511;
  int D.27512;
  struct MonoMemPool * D.27513;
  long int D.27514;
  struct MonoInst * D.27515;
  short unsigned int D.27516;
  int D.27517;
  int D.27518;
  const unsigned char * D.27519;
  long int D.27520;
  struct MonoClass * D.27521;
  struct MonoClass * D.27522;
  unsigned char D.27523;
  long unsigned int D.27526;
  long unsigned int D.27527;
  long unsigned int D.27530;
  long unsigned int D.27531;
  int D.27538;
  long unsigned int D.27540;
  long unsigned int D.27541;
  int D.27542;
  unsigned char D.27543;
  unsigned char D.27544;
  long unsigned int D.27545;
  long unsigned int D.27546;
  struct MonoInst * * D.27547;
  long unsigned int D.27548;
  struct MonoMethodVar * D.27549;
  unsigned int num.18;
  unsigned int D.27555;
  int D.27558;
  int D.27559;
  int D.27560;
  int D.27561;
  unsigned int D.27564;
  unsigned int D.27565;
  unsigned char D.27570;
  unsigned char D.27571;
  long int D.27574;
  struct MonoInst * D.27575;
  int D.27576;
  int D.27577;
  struct MonoClass * D.27580;
  struct MonoType * D.27581;
  struct MonoType * D.27582;
  struct MonoClass * D.27583;
  struct MonoClass * D.27586;
  unsigned int D.27587;
  char * D.27590;
  struct MonoInst * D.27591;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.27487 = cfg->num_varinfo;
  num = (int) D.27487;
  type = mini_replace_type (type);
  D.27488 = num + 1;
  D.27489 = (unsigned int) D.27488;
  D.27490 = cfg->varinfo_count;
  if (D.27489 >= D.27490) goto <D.27491>; else goto <D.27492>;
  <D.27491>:
  {
    int orig_count;

    D.27490 = cfg->varinfo_count;
    orig_count = (int) D.27490;
    D.27490 = cfg->varinfo_count;
    if (D.27490 != 0) goto <D.27494>; else goto <D.27495>;
    <D.27494>:
    D.27490 = cfg->varinfo_count;
    iftmp.16 = D.27490 * 2;
    goto <D.27496>;
    <D.27495>:
    iftmp.16 = 64;
    <D.27496>:
    cfg->varinfo_count = iftmp.16;
    D.27497 = cfg->varinfo;
    D.27490 = cfg->varinfo_count;
    D.27498 = (long unsigned int) D.27490;
    D.27499 = D.27498 * 8;
    D.27500 = monoeg_realloc (D.27497, D.27499);
    cfg->varinfo = D.27500;
    D.27501 = cfg->vars;
    D.27490 = cfg->varinfo_count;
    D.27498 = (long unsigned int) D.27490;
    D.27502 = D.27498 * 80;
    D.27503 = monoeg_realloc (D.27501, D.27502);
    cfg->vars = D.27503;
    D.27501 = cfg->vars;
    D.27504 = (long unsigned int) orig_count;
    D.27505 = D.27504 * 80;
    D.27506 = D.27501 + D.27505;
    D.27490 = cfg->varinfo_count;
    orig_count.17 = (unsigned int) orig_count;
    D.27508 = D.27490 - orig_count.17;
    D.27509 = (long unsigned int) D.27508;
    D.27510 = D.27509 * 80;
    memset (D.27506, 0, D.27510);
  }
  <D.27492>:
  D.27511 = cfg->stat_allocate_var;
  D.27512 = D.27511 + 1;
  cfg->stat_allocate_var = D.27512;
  D.27513 = cfg->mempool;
  inst = mono_mempool_alloc (D.27513, 80);
  inst->data.op[1].const_val = 0;
  D.27514 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.27514;
  inst->prev = 0B;
  D.27515 = inst->prev;
  inst->next = D.27515;
  D.27516 = (short unsigned int) opcode;
  inst->opcode = D.27516;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.27517 = inst->sreg3;
  inst->sreg2 = D.27517;
  D.27518 = inst->sreg2;
  inst->sreg1 = D.27518;
  D.27519 = cfg->ip;
  inst->cil_code = D.27519;
  D.27520 = (long int) num;
  inst->data.op[0].const_val = D.27520;
  inst->data.op[1].vtype = type;
  D.27521 = mono_class_from_mono_type (type);
  inst->klass = D.27521;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.27522 = inst->klass;
  D.27523 = D.27522->exception_type;
  if (D.27523 != 0) goto <D.27524>; else goto <D.27525>;
  <D.27524>:
  mono_cfg_set_exception (cfg, 7);
  <D.27525>:
  D.27526 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.27527 = D.27526 & 72057594037927936;
  if (D.27527 != 0) goto <D.27528>; else goto <D.27529>;
  <D.27528>:
  D.27530 = BIT_FIELD_REF <*type, 64, 64>;
  D.27531 = D.27530 & 8589934592;
  if (D.27531 != 0) goto <D.27532>; else goto <D.27533>;
  <D.27532>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.27534>;
  <D.27533>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.27538 = mono_type_is_struct (t);
    if (D.27538 != 0) goto <D.27539>; else goto <D.27535>;
    <D.27539>:
    D.27522 = inst->klass;
    D.27540 = BIT_FIELD_REF <*D.27522, 64, 256>;
    D.27541 = D.27540 & 68719476736;
    if (D.27541 != 0) goto <D.27536>; else goto <D.27535>;
    <D.27535>:
    D.27542 = mini_type_is_reference (cfg, t);
    if (D.27542 != 0) goto <D.27536>; else goto <D.27537>;
    <D.27536>:
    D.27543 = inst->flags;
    D.27544 = D.27543 | 128;
    inst->flags = D.27544;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.27537>:
  }
  <D.27534>:
  <D.27529>:
  D.27497 = cfg->varinfo;
  D.27545 = (long unsigned int) num;
  D.27546 = D.27545 * 8;
  D.27547 = D.27497 + D.27546;
  *D.27547 = inst;
  D.27501 = cfg->vars;
  D.27545 = (long unsigned int) num;
  D.27548 = D.27545 * 80;
  D.27549 = D.27501 + D.27548;
  D.27549->range.first_use.pos.bid = 65535;
  D.27501 = cfg->vars;
  D.27545 = (long unsigned int) num;
  D.27548 = D.27545 * 80;
  D.27549 = D.27501 + D.27548;
  D.27549->reg = -1;
  D.27501 = cfg->vars;
  D.27545 = (long unsigned int) num;
  D.27548 = D.27545 * 80;
  D.27549 = D.27501 + D.27548;
  num.18 = (unsigned int) num;
  D.27549->idx = num.18;
  D.27501 = cfg->vars;
  D.27545 = (long unsigned int) num;
  D.27548 = D.27545 * 80;
  D.27549 = D.27501 + D.27548;
  D.27549->vreg = vreg;
  if (vreg != -1) goto <D.27551>; else goto <D.27552>;
  <D.27551>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.27552>:
  regpair = 0;
  if (regpair != 0) goto <D.27553>; else goto <D.27554>;
  <D.27553>:
  {
    struct MonoInst * tree;

    D.27555 = cfg->verbose_level;
    if (D.27555 > 3) goto <D.27556>; else goto <D.27557>;
    <D.27556>:
    D.27558 = inst->dreg;
    D.27558 = inst->dreg;
    D.27559 = D.27558 + 1;
    D.27558 = inst->dreg;
    D.27560 = D.27558 + 2;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.27558, D.27559, D.27560);
    <D.27557>:
    D.27561 = mono_arch_is_soft_float ();
    if (D.27561 != 0) goto <D.27562>; else goto <D.27563>;
    <D.27562>:
    D.27564 = cfg->opt;
    D.27565 = D.27564 & 2097152;
    if (D.27565 != 0) goto <D.27566>; else goto <D.27567>;
    <D.27566>:
    D.27530 = BIT_FIELD_REF <*type, 64, 64>;
    D.27531 = D.27530 & 8589934592;
    if (D.27531 == 0) goto <D.27568>; else goto <D.27569>;
    <D.27568>:
    D.27570 = type->type;
    D.27571 = D.27570 + 244;
    if (D.27571 <= 1) goto <D.27572>; else goto <D.27573>;
    <D.27572>:
    inst->flags = 4;
    <D.27573>:
    <D.27569>:
    <D.27567>:
    <D.27563>:
    D.27513 = cfg->mempool;
    tree = mono_mempool_alloc (D.27513, 80);
    tree->data.op[1].const_val = 0;
    D.27574 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27574;
    tree->prev = 0B;
    D.27575 = tree->prev;
    tree->next = D.27575;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27576 = tree->sreg3;
    tree->sreg2 = D.27576;
    D.27577 = tree->sreg2;
    tree->sreg1 = D.27577;
    D.27519 = cfg->ip;
    tree->cil_code = D.27519;
    D.27558 = inst->dreg;
    D.27559 = D.27558 + 1;
    tree->dreg = D.27559;
    D.27564 = cfg->opt;
    D.27565 = D.27564 & 2097152;
    if (D.27565 != 0) goto <D.27578>; else goto <D.27579>;
    <D.27578>:
    tree->flags = 4;
    <D.27579>:
    D.27520 = (long int) num;
    tree->data.op[0].const_val = D.27520;
    tree->type = 1;
    D.27580 = mono_defaults.int32_class;
    D.27581 = &D.27580->byval_arg;
    tree->data.op[1].vtype = D.27581;
    D.27582 = tree->data.op[1].vtype;
    D.27583 = mono_class_from_mono_type (D.27582);
    tree->klass = D.27583;
    D.27558 = inst->dreg;
    D.27559 = D.27558 + 1;
    set_vreg_to_inst (cfg, D.27559, tree);
    D.27513 = cfg->mempool;
    tree = mono_mempool_alloc (D.27513, 80);
    tree->data.op[1].const_val = 0;
    D.27574 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27574;
    tree->prev = 0B;
    D.27575 = tree->prev;
    tree->next = D.27575;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27576 = tree->sreg3;
    tree->sreg2 = D.27576;
    D.27577 = tree->sreg2;
    tree->sreg1 = D.27577;
    D.27519 = cfg->ip;
    tree->cil_code = D.27519;
    D.27558 = inst->dreg;
    D.27560 = D.27558 + 2;
    tree->dreg = D.27560;
    D.27564 = cfg->opt;
    D.27565 = D.27564 & 2097152;
    if (D.27565 != 0) goto <D.27584>; else goto <D.27585>;
    <D.27584>:
    tree->flags = 4;
    <D.27585>:
    D.27520 = (long int) num;
    tree->data.op[0].const_val = D.27520;
    tree->type = 1;
    D.27580 = mono_defaults.int32_class;
    D.27581 = &D.27580->byval_arg;
    tree->data.op[1].vtype = D.27581;
    D.27582 = tree->data.op[1].vtype;
    D.27586 = mono_class_from_mono_type (D.27582);
    tree->klass = D.27586;
    D.27558 = inst->dreg;
    D.27560 = D.27558 + 2;
    set_vreg_to_inst (cfg, D.27560, tree);
  }
  <D.27554>:
  D.27487 = cfg->num_varinfo;
  D.27587 = D.27487 + 1;
  cfg->num_varinfo = D.27587;
  D.27555 = cfg->verbose_level;
  if (D.27555 > 2) goto <D.27588>; else goto <D.27589>;
  <D.27588>:
  D.27590 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.27590);
  <D.27589>:
  D.27591 = inst;
  return D.27591;
}


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

  D.27594 = __builtin_object_size (__dest, 0);
  D.27593 = __builtin___memset_chk (__dest, __ch, __len, D.27594);
  return D.27593;
}


__attribute__((always_inline))
mono_arch_is_soft_float ()
{
  gboolean D.27596;

  D.27596 = 0;
  return D.27596;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int D.27598;
  unsigned int vreg.19;
  guint32 iftmp.20;
  struct MonoMemPool * D.27606;
  unsigned int D.27607;
  void * D.27608;
  struct MonoInst * * D.27611;
  long unsigned int D.27612;
  long unsigned int D.27613;
  long unsigned int D.27614;
  long unsigned int D.27615;
  struct MonoInst * * D.27616;

  D.27598 = cfg->vreg_to_inst_len;
  vreg.19 = (unsigned int) vreg;
  if (D.27598 <= vreg.19) goto <D.27600>; else goto <D.27601>;
  <D.27600>:
  {
    struct MonoInst * * tmp;
    int size;

    tmp = cfg->vreg_to_inst;
    D.27598 = cfg->vreg_to_inst_len;
    size = (int) D.27598;
    goto <D.25424>;
    <D.25423>:
    D.27598 = cfg->vreg_to_inst_len;
    if (D.27598 != 0) goto <D.27603>; else goto <D.27604>;
    <D.27603>:
    D.27598 = cfg->vreg_to_inst_len;
    iftmp.20 = D.27598 * 2;
    goto <D.27605>;
    <D.27604>:
    iftmp.20 = 32;
    <D.27605>:
    cfg->vreg_to_inst_len = iftmp.20;
    <D.25424>:
    D.27598 = cfg->vreg_to_inst_len;
    vreg.19 = (unsigned int) vreg;
    if (D.27598 <= vreg.19) goto <D.25423>; else goto <D.25425>;
    <D.25425>:
    D.27606 = cfg->mempool;
    D.27598 = cfg->vreg_to_inst_len;
    D.27607 = D.27598 * 8;
    D.27608 = mono_mempool_alloc0 (D.27606, D.27607);
    cfg->vreg_to_inst = D.27608;
    if (size != 0) goto <D.27609>; else goto <D.27610>;
    <D.27609>:
    D.27611 = cfg->vreg_to_inst;
    D.27612 = (long unsigned int) size;
    D.27613 = D.27612 * 8;
    memcpy (D.27611, tmp, D.27613);
    <D.27610>:
  }
  <D.27601>:
  D.27611 = cfg->vreg_to_inst;
  D.27614 = (long unsigned int) vreg;
  D.27615 = D.27614 * 8;
  D.27616 = D.27611 + D.27615;
  *D.27616 = inst;
}


__attribute__((visibility ("hidden")))
mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  long unsigned int D.27620;
  long unsigned int D.27621;
  struct MonoType * D.27623;
  unsigned char D.27624;
  struct MonoType * D.27626;
  unsigned char D.27627;
  unsigned int D.27628;
  int D.27631;
  unsigned char D.27634;
  unsigned char D.27635;
  unsigned int D.27637;
  unsigned int D.27638;
  struct MonoInst * D.27639;
  int dreg;

  type = mini_replace_type (type);
  D.27620 = BIT_FIELD_REF <*type, 64, 64>;
  D.27621 = D.27620 & 8589934592;
  if (D.27621 == 0) goto <D.27622>; else goto <D.27617>;
  <D.27622>:
  D.27623 = mono_type_get_underlying_type (type);
  D.27624 = D.27623->type;
  if (D.27624 == 10) goto <D.27618>; else goto <D.27625>;
  <D.27625>:
  D.27626 = mono_type_get_underlying_type (type);
  D.27627 = D.27626->type;
  if (D.27627 == 11) goto <D.27618>; else goto <D.27617>;
  <D.27618>:
  D.27628 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.27628;
  goto <D.27619>;
  <D.27617>:
  D.27631 = mono_arch_is_soft_float ();
  if (D.27631 != 0) goto <D.27632>; else goto <D.27629>;
  <D.27632>:
  D.27620 = BIT_FIELD_REF <*type, 64, 64>;
  D.27621 = D.27620 & 8589934592;
  if (D.27621 == 0) goto <D.27633>; else goto <D.27629>;
  <D.27633>:
  D.27634 = type->type;
  D.27635 = D.27634 + 244;
  if (D.27635 <= 1) goto <D.27636>; else goto <D.27629>;
  <D.27636>:
  D.27637 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.27637;
  goto <D.27630>;
  <D.27629>:
  D.27638 = mono_alloc_preg (cfg);
  dreg = (int) D.27638;
  <D.27630>:
  <D.27619>:
  D.27639 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.27639;
}


__attribute__((visibility ("hidden")))
mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.27641;
  long unsigned int var_index.21;
  long unsigned int D.27643;
  struct MonoInst * * D.27644;
  struct MonoInst * D.27645;
  struct MonoInst * D.27646;
  struct MonoType * D.27647;
  unsigned int D.27648;
  short unsigned int D.27649;
  struct MonoClass * D.27650;

  memset (dest, 0, 80);
  D.27641 = cfg->varinfo;
  var_index.21 = (long unsigned int) var_index;
  D.27643 = var_index.21 * 8;
  D.27644 = D.27641 + D.27643;
  D.27645 = *D.27644;
  dest->data.op[0].src = D.27645;
  D.27646 = dest->data.op[0].src;
  D.27647 = D.27646->data.op[1].vtype;
  D.27648 = mini_type_to_ldind (cfg, D.27647);
  D.27649 = (short unsigned int) D.27648;
  dest->opcode = D.27649;
  D.27646 = dest->data.op[0].src;
  D.27647 = D.27646->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.27647, dest);
  D.27646 = dest->data.op[0].src;
  D.27650 = D.27646->klass;
  dest->klass = D.27650;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27651;
  long unsigned int D.27654;
  long unsigned int D.27655;
  unsigned char D.27660;
  int D.27662;
  guint D.27665;

  D.27651 = cfg->generic_sharing_context;
  if (D.27651 != 0B) goto <D.27652>; else goto <D.27653>;
  <D.27652>:
  D.27654 = BIT_FIELD_REF <*type, 64, 64>;
  D.27655 = D.27654 & 8589934592;
  if (D.27655 == 0) goto <D.27656>; else goto <D.27657>;
  <D.27656>:
  D.27660 = type->type;
  if (D.27660 == 19) goto <D.27658>; else goto <D.27661>;
  <D.27661>:
  D.27660 = type->type;
  if (D.27660 == 30) goto <D.27658>; else goto <D.27659>;
  <D.27658>:
  D.27662 = mini_type_var_is_vt (cfg, type);
  if (D.27662 != 0) goto <D.27663>; else goto <D.27664>;
  <D.27663>:
  D.27665 = 113;
  return D.27665;
  <D.27664>:
  D.27665 = 80;
  return D.27665;
  <D.27659>:
  <D.27657>:
  <D.27653>:
  D.27665 = mono_type_to_ldind (type);
  return D.27665;
}


__attribute__((visibility ("hidden")))
mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int D.27667;
  unsigned int vreg.22;
  guint32 iftmp.23;
  struct MonoMemPool * D.27675;
  unsigned int D.27676;
  void * D.27677;
  gboolean * D.27680;
  long unsigned int D.27681;
  long unsigned int D.27682;
  long unsigned int D.27683;
  long unsigned int D.27684;
  gboolean * D.27685;

  D.27667 = cfg->vreg_is_ref_len;
  vreg.22 = (unsigned int) vreg;
  if (D.27667 <= vreg.22) goto <D.27669>; else goto <D.27670>;
  <D.27669>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_ref;
    D.27667 = cfg->vreg_is_ref_len;
    size = (int) D.27667;
    goto <D.25456>;
    <D.25455>:
    D.27667 = cfg->vreg_is_ref_len;
    if (D.27667 != 0) goto <D.27672>; else goto <D.27673>;
    <D.27672>:
    D.27667 = cfg->vreg_is_ref_len;
    iftmp.23 = D.27667 * 2;
    goto <D.27674>;
    <D.27673>:
    iftmp.23 = 32;
    <D.27674>:
    cfg->vreg_is_ref_len = iftmp.23;
    <D.25456>:
    D.27667 = cfg->vreg_is_ref_len;
    vreg.22 = (unsigned int) vreg;
    if (D.27667 <= vreg.22) goto <D.25455>; else goto <D.25457>;
    <D.25457>:
    D.27675 = cfg->mempool;
    D.27667 = cfg->vreg_is_ref_len;
    D.27676 = D.27667 * 4;
    D.27677 = mono_mempool_alloc0 (D.27675, D.27676);
    cfg->vreg_is_ref = D.27677;
    if (size != 0) goto <D.27678>; else goto <D.27679>;
    <D.27678>:
    D.27680 = cfg->vreg_is_ref;
    D.27681 = (long unsigned int) size;
    D.27682 = D.27681 * 4;
    memcpy (D.27680, tmp, D.27682);
    <D.27679>:
  }
  <D.27670>:
  D.27680 = cfg->vreg_is_ref;
  D.27683 = (long unsigned int) vreg;
  D.27684 = D.27683 * 4;
  D.27685 = D.27680 + D.27684;
  *D.27685 = 1;
}


__attribute__((visibility ("hidden")))
mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int D.27686;
  unsigned int vreg.24;
  guint32 iftmp.25;
  struct MonoMemPool * D.27694;
  unsigned int D.27695;
  void * D.27696;
  gboolean * D.27699;
  long unsigned int D.27700;
  long unsigned int D.27701;
  long unsigned int D.27702;
  long unsigned int D.27703;
  gboolean * D.27704;

  D.27686 = cfg->vreg_is_mp_len;
  vreg.24 = (unsigned int) vreg;
  if (D.27686 <= vreg.24) goto <D.27688>; else goto <D.27689>;
  <D.27688>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_mp;
    D.27686 = cfg->vreg_is_mp_len;
    size = (int) D.27686;
    goto <D.25465>;
    <D.25464>:
    D.27686 = cfg->vreg_is_mp_len;
    if (D.27686 != 0) goto <D.27691>; else goto <D.27692>;
    <D.27691>:
    D.27686 = cfg->vreg_is_mp_len;
    iftmp.25 = D.27686 * 2;
    goto <D.27693>;
    <D.27692>:
    iftmp.25 = 32;
    <D.27693>:
    cfg->vreg_is_mp_len = iftmp.25;
    <D.25465>:
    D.27686 = cfg->vreg_is_mp_len;
    vreg.24 = (unsigned int) vreg;
    if (D.27686 <= vreg.24) goto <D.25464>; else goto <D.25466>;
    <D.25466>:
    D.27694 = cfg->mempool;
    D.27686 = cfg->vreg_is_mp_len;
    D.27695 = D.27686 * 4;
    D.27696 = mono_mempool_alloc0 (D.27694, D.27695);
    cfg->vreg_is_mp = D.27696;
    if (size != 0) goto <D.27697>; else goto <D.27698>;
    <D.27697>:
    D.27699 = cfg->vreg_is_mp;
    D.27700 = (long unsigned int) size;
    D.27701 = D.27700 * 4;
    memcpy (D.27699, tmp, D.27701);
    <D.27698>:
  }
  <D.27689>:
  D.27699 = cfg->vreg_is_mp;
  D.27702 = (long unsigned int) vreg;
  D.27703 = D.27702 * 4;
  D.27704 = D.27699 + D.27703;
  *D.27704 = 1;
}


__attribute__((visibility ("hidden")))
mono_type_from_stack_type (struct MonoInst * ins)
{
  struct MonoType * D.27705;

  D.27705 = type_from_stack_type (ins);
  return D.27705;
}


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.27707;
  int D.27708;
  struct MonoType * D.27709;
  struct MonoClass * D.27710;
  struct MonoClass * D.27711;
  struct MonoClass * D.27712;
  struct MonoClass * D.27713;
  struct MonoClass * D.27714;
  struct MonoClass * D.27717;
  long unsigned int D.27720;
  long unsigned int D.27721;

  D.27707 = ins->type;
  D.27708 = (int) D.27707;
  switch (D.27708) <default: <D.25477>, case 1: <D.25470>, case 2: <D.25471>, case 3: <D.25472>, case 4: <D.25473>, case 5: <D.25474>, case 6: <D.25475>, case 7: <D.25476>>
  <D.25470>:
  D.27710 = mono_defaults.int32_class;
  D.27709 = &D.27710->byval_arg;
  return D.27709;
  <D.25471>:
  D.27711 = mono_defaults.int64_class;
  D.27709 = &D.27711->byval_arg;
  return D.27709;
  <D.25472>:
  D.27712 = mono_defaults.int_class;
  D.27709 = &D.27712->byval_arg;
  return D.27709;
  <D.25473>:
  D.27713 = mono_defaults.double_class;
  D.27709 = &D.27713->byval_arg;
  return D.27709;
  <D.25474>:
  D.27714 = ins->klass;
  if (D.27714 != 0B) goto <D.27715>; else goto <D.27716>;
  <D.27715>:
  D.27714 = ins->klass;
  D.27709 = &D.27714->this_arg;
  return D.27709;
  <D.27716>:
  D.27717 = mono_defaults.object_class;
  D.27709 = &D.27717->this_arg;
  return D.27709;
  <D.25475>:
  D.27714 = ins->klass;
  if (D.27714 != 0B) goto <D.27718>; else goto <D.27719>;
  <D.27718>:
  D.27714 = ins->klass;
  D.27720 = BIT_FIELD_REF <*D.27714, 64, 256>;
  D.27721 = D.27720 & 1152921504606846976;
  if (D.27721 == 0) goto <D.27722>; else goto <D.27723>;
  <D.27722>:
  D.27714 = ins->klass;
  D.27709 = &D.27714->byval_arg;
  return D.27709;
  <D.27723>:
  <D.27719>:
  D.27717 = mono_defaults.object_class;
  D.27709 = &D.27717->byval_arg;
  return D.27709;
  <D.25476>:
  D.27714 = ins->klass;
  D.27709 = &D.27714->byval_arg;
  return D.27709;
  <D.25477>:
  D.27707 = ins->type;
  D.27708 = (int) D.27707;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.27708);
  <D.25478>:
  goto <D.25478>;
  D.27709 = 0B;
  return D.27709;
}


__attribute__((visibility ("hidden")))
mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.27725;
  struct MonoInst * D.27728;
  short unsigned int D.27732;
  int D.27733;
  short unsigned int D.27737;
  short unsigned int D.27739;
  short unsigned int D.27741;
  struct MonoInst * D.27744;
  short unsigned int D.27747;
  unsigned int opcode.26;
  unsigned int D.27752;
  struct MonoInst * D.27759;
  short unsigned int D.27760;
  int opcode;

  D.27725 = bb->code;
  if (D.27725 == 0B) goto <D.27726>; else goto <D.27727>;
  <D.27726>:
  D.27728 = bb->last_ins;
  if (D.27728 != 0B) goto <D.27729>; else goto <D.27730>;
  <D.27729>:
  D.27728 = bb->last_ins;
  D.27728->next = inst;
  D.27728 = bb->last_ins;
  inst->prev = D.27728;
  bb->last_ins = inst;
  goto <D.27731>;
  <D.27730>:
  bb->last_ins = inst;
  D.27728 = bb->last_ins;
  bb->code = D.27728;
  <D.27731>:
  return;
  <D.27727>:
  D.27728 = bb->last_ins;
  D.27732 = D.27728->opcode;
  D.27733 = (int) D.27732;
  switch (D.27733) <default: <D.25501>, case 59: <D.25489>, case 60: <D.25490>, case 61: <D.25491>, case 62: <D.25492>, case 63: <D.25493>, case 64: <D.25494>, case 65: <D.25495>, case 66: <D.25496>, case 67: <D.25497>, case 68: <D.25498>, case 370: <D.25499>, case 442: <D.25487>, case 759: <D.25488>>
  <D.25487>:
  <D.25488>:
  <D.25489>:
  <D.25490>:
  <D.25491>:
  <D.25492>:
  <D.25493>:
  <D.25494>:
  <D.25495>:
  <D.25496>:
  <D.25497>:
  <D.25498>:
  <D.25499>:
  D.27728 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27728, inst);
  goto <D.25500>;
  <D.25501>:
  D.27728 = bb->last_ins;
  D.27732 = D.27728->opcode;
  D.27737 = D.27732 + 64985;
  if (D.27737 <= 9) goto <D.27734>; else goto <D.27738>;
  <D.27738>:
  D.27728 = bb->last_ins;
  D.27732 = D.27728->opcode;
  D.27739 = D.27732 + 64878;
  if (D.27739 <= 9) goto <D.27734>; else goto <D.27740>;
  <D.27740>:
  D.27728 = bb->last_ins;
  D.27732 = D.27728->opcode;
  D.27741 = D.27732 + 64888;
  if (D.27741 <= 9) goto <D.27734>; else goto <D.27735>;
  <D.27734>:
  D.27725 = bb->code;
  D.27728 = bb->last_ins;
  if (D.27725 == D.27728) goto <D.27742>; else goto <D.27743>;
  <D.27742>:
  D.27728 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27728, inst);
  return;
  <D.27743>:
  D.27725 = bb->code;
  D.27744 = D.27725->next;
  D.27728 = bb->last_ins;
  if (D.27744 == D.27728) goto <D.27745>; else goto <D.27746>;
  <D.27745>:
  D.27725 = bb->code;
  D.27747 = D.27725->opcode;
  opcode = (int) D.27747;
  opcode.26 = (unsigned int) opcode;
  D.27752 = opcode.26 + 4294966974;
  if (D.27752 <= 1) goto <D.27748>; else goto <D.27753>;
  <D.27753>:
  if (opcode == 326) goto <D.27748>; else goto <D.27754>;
  <D.27754>:
  if (opcode == 327) goto <D.27748>; else goto <D.27755>;
  <D.27755>:
  if (opcode == 324) goto <D.27748>; else goto <D.27756>;
  <D.27756>:
  if (opcode == 325) goto <D.27748>; else goto <D.27757>;
  <D.27757>:
  if (opcode == 328) goto <D.27748>; else goto <D.27749>;
  <D.27748>:
  D.27725 = bb->code;
  mono_bblock_insert_before_ins (bb, D.27725, inst);
  goto <D.27750>;
  <D.27749>:
  D.27728 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27728, inst);
  <D.27750>:
  goto <D.27758>;
  <D.27746>:
  D.27728 = bb->last_ins;
  D.27759 = D.27728->prev;
  D.27760 = D.27759->opcode;
  opcode = (int) D.27760;
  opcode.26 = (unsigned int) opcode;
  D.27752 = opcode.26 + 4294966974;
  if (D.27752 <= 1) goto <D.27761>; else goto <D.27764>;
  <D.27764>:
  if (opcode == 326) goto <D.27761>; else goto <D.27765>;
  <D.27765>:
  if (opcode == 327) goto <D.27761>; else goto <D.27766>;
  <D.27766>:
  if (opcode == 324) goto <D.27761>; else goto <D.27767>;
  <D.27767>:
  if (opcode == 325) goto <D.27761>; else goto <D.27768>;
  <D.27768>:
  if (opcode == 328) goto <D.27761>; else goto <D.27762>;
  <D.27761>:
  D.27728 = bb->last_ins;
  D.27759 = D.27728->prev;
  mono_bblock_insert_before_ins (bb, D.27759, inst);
  goto <D.27763>;
  <D.27762>:
  D.27728 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27728, inst);
  <D.27763>:
  <D.27758>:
  goto <D.27736>;
  <D.27735>:
  D.27728 = bb->last_ins;
  if (D.27728 != 0B) goto <D.27769>; else goto <D.27770>;
  <D.27769>:
  D.27728 = bb->last_ins;
  D.27728->next = inst;
  D.27728 = bb->last_ins;
  inst->prev = D.27728;
  bb->last_ins = inst;
  goto <D.27771>;
  <D.27770>:
  bb->last_ins = inst;
  D.27728 = bb->last_ins;
  bb->code = D.27728;
  <D.27771>:
  <D.27736>:
  goto <D.25500>;
  <D.25500>:
}


__attribute__((visibility ("hidden")))
mono_create_jump_table (struct MonoCompile * cfg, struct MonoInst * label, struct MonoBasicBlock * * bbs, int num_blocks)
{
  struct MonoMemPool * D.27773;
  struct MonoJumpInfo * D.27774;
  struct MonoJumpInfo * ji;
  struct MonoJumpInfoBBTable * table;

  D.27773 = cfg->mempool;
  ji = mono_mempool_alloc (D.27773, 40);
  D.27773 = cfg->mempool;
  table = mono_mempool_alloc (D.27773, 16);
  table->table = bbs;
  table->table_size = num_blocks;
  ji->ip.label = label;
  ji->type = 8;
  ji->data.table = table;
  D.27774 = cfg->patch_info;
  ji->next = D.27774;
  cfg->patch_info = ji;
}


__attribute__((visibility ("hidden")))
mono_get_array_new_va_icall (int rank)
{
  _Bool D.27777;
  long int D.27778;
  long int D.27779;
  struct GHashTable * jit_icall_name_hash.27;
  _Bool D.27787;
  long int D.27788;
  long int D.27789;
  struct MonoJitICallInfo * D.27792;
  struct MonoMethodSignature * esig;
  char icall_name[256];
  char * name;
  struct MonoJitICallInfo * info;

  try
    {
      sprintf (&icall_name, "ves_array_new_va_%d", rank);
      {
        int ret;

        ret = pthread_mutex_lock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27775>; else goto <D.27776>;
        <D.27775>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27776>:
        D.27777 = ret != 0;
        D.27778 = (long int) D.27777;
        D.27779 = __builtin_expect (D.27778, 0);
        if (D.27779 != 0) goto <D.27780>; else goto <D.27781>;
        <D.27780>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.27781>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.27782>; else goto <D.27783>;
      <D.27782>:
      esig = mono_get_array_new_va_signature (rank);
      name = monoeg_strdup (&icall_name);
      info = mono_register_jit_icall (mono_array_new_va, name, esig, 0);
      jit_icall_name_hash.27 = jit_icall_name_hash;
      monoeg_g_hash_table_insert_replace (jit_icall_name_hash.27, name, name, 0);
      <D.27783>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27785>; else goto <D.27786>;
        <D.27785>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27786>:
        D.27787 = ret != 0;
        D.27788 = (long int) D.27787;
        D.27789 = __builtin_expect (D.27788, 0);
        if (D.27789 != 0) goto <D.27790>; else goto <D.27791>;
        <D.27790>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.27791>:
      }
      D.27792 = info;
      return D.27792;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.27795;
  long unsigned int D.27796;

  D.27796 = __builtin_object_size (__s, 1);
  D.27795 = __builtin___sprintf_chk (__s, 1, D.27796, __fmt, __builtin_va_arg_pack ());
  return D.27795;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.27800;
  long int D.27801;
  long int D.27802;
  struct GHashTable * sighash.28;
  struct GHashTable * sighash.29;
  long int D.27810;
  const void * D.27811;
  _Bool D.27816;
  long int D.27817;
  long int D.27818;
  struct MonoMethodSignature * D.27821;
  struct MonoImage * D.27822;
  int D.27823;
  unsigned int D.27824;
  struct MonoClass * D.27827;
  struct MonoType * D.27828;
  int D.27829;
  struct MonoClass * D.27830;
  struct MonoType * D.27831;
  void * D.27832;
  _Bool D.27835;
  long int D.27836;
  long int D.27837;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27798>; else goto <D.27799>;
    <D.27798>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27799>:
    D.27800 = ret != 0;
    D.27801 = (long int) D.27800;
    D.27802 = __builtin_expect (D.27801, 0);
    if (D.27802 != 0) goto <D.27803>; else goto <D.27804>;
    <D.27803>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.27804>:
  }
  sighash.28 = sighash;
  if (sighash.28 == 0B) goto <D.27806>; else goto <D.27807>;
  <D.27806>:
  sighash.29 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.29;
  goto <D.27809>;
  <D.27807>:
  sighash.28 = sighash;
  D.27810 = (long int) arity;
  D.27811 = (const void *) D.27810;
  res = monoeg_g_hash_table_lookup (sighash.28, D.27811);
  if (res != 0B) goto <D.27812>; else goto <D.27813>;
  <D.27812>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27814>; else goto <D.27815>;
    <D.27814>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27815>:
    D.27816 = ret != 0;
    D.27817 = (long int) D.27816;
    D.27818 = __builtin_expect (D.27817, 0);
    if (D.27818 != 0) goto <D.27819>; else goto <D.27820>;
    <D.27819>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.27820>:
  }
  D.27821 = res;
  return D.27821;
  <D.27813>:
  <D.27809>:
  D.27822 = mono_defaults.corlib;
  D.27823 = arity + 1;
  D.27824 = (unsigned int) D.27823;
  res = mono_metadata_signature_alloc (D.27822, D.27824);
  res->pinvoke = 1;
  if (0 != 0) goto <D.27825>; else goto <D.27826>;
  <D.27825>:
  res->call_convention = 5;
  <D.27826>:
  D.27827 = mono_defaults.int_class;
  D.27828 = &D.27827->byval_arg;
  res->params[0] = D.27828;
  i = 0;
  goto <D.25519>;
  <D.25518>:
  D.27829 = i + 1;
  D.27827 = mono_defaults.int_class;
  D.27828 = &D.27827->byval_arg;
  res->params[D.27829] = D.27828;
  i = i + 1;
  <D.25519>:
  if (i < arity) goto <D.25518>; else goto <D.25520>;
  <D.25520>:
  D.27830 = mono_defaults.object_class;
  D.27831 = &D.27830->byval_arg;
  res->ret = D.27831;
  sighash.28 = sighash;
  D.27810 = (long int) arity;
  D.27832 = (void *) D.27810;
  monoeg_g_hash_table_insert_replace (sighash.28, D.27832, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27833>; else goto <D.27834>;
    <D.27833>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27834>:
    D.27835 = ret != 0;
    D.27836 = (long int) D.27835;
    D.27837 = __builtin_expect (D.27836, 0);
    if (D.27837 != 0) goto <D.27838>; else goto <D.27839>;
    <D.27838>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.27839>:
  }
  D.27821 = res;
  return D.27821;
}


__attribute__((visibility ("hidden")))
mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.27841;
  struct MonoClass * D.27842;
  gboolean D.27845;

  D.27841 = klass->parent;
  D.27842 = mono_defaults.array_class;
  if (D.27841 == D.27842) goto <D.27843>; else goto <D.27844>;
  <D.27843>:
  D.27845 = 1;
  return D.27845;
  <D.27844>:
  D.27845 = 0;
  return D.27845;
}


__attribute__((visibility ("hidden")))
mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.27847;
  struct MonoImage * D.27848;
  long unsigned int D.27849;
  long unsigned int D.27850;
  gboolean D.27855;
  unsigned char D.27858;
  struct MonoImage * D.27860;
  struct MonoImage * D.27861;
  int D.27862;
  struct MonoAssembly * assembly;

  D.27847 = method->klass;
  D.27848 = D.27847->image;
  assembly = D.27848->assembly;
  D.27849 = BIT_FIELD_REF <*method, 64, 256>;
  D.27850 = D.27849 & 4467570830351532032;
  if (D.27850 != 0) goto <D.27851>; else goto <D.27852>;
  <D.27851>:
  D.27849 = BIT_FIELD_REF <*method, 64, 256>;
  D.27850 = D.27849 & 4467570830351532032;
  if (D.27850 != 2449958197289549824) goto <D.27853>; else goto <D.27854>;
  <D.27853>:
  D.27855 = 0;
  return D.27855;
  <D.27854>:
  <D.27852>:
  D.27858 = assembly->in_gac;
  if (D.27858 != 0) goto <D.27856>; else goto <D.27859>;
  <D.27859>:
  D.27860 = assembly->image;
  D.27861 = mono_defaults.corlib;
  if (D.27860 == D.27861) goto <D.27856>; else goto <D.27857>;
  <D.27856>:
  D.27855 = 0;
  return D.27855;
  <D.27857>:
  D.27862 = mono_is_security_manager_active ();
  if (D.27862 != 0) goto <D.27863>; else goto <D.27864>;
  <D.27863>:
  D.27855 = 0;
  return D.27855;
  <D.27864>:
  D.27855 = mono_assembly_has_skip_verification (assembly);
  return D.27855;
}


__attribute__((visibility ("hidden")))
mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.27866;
  struct MonoImage * D.27867;
  struct MonoAssembly * D.27868;
  unsigned char D.27869;
  long unsigned int D.27870;
  long unsigned int D.27871;
  gboolean D.27872;
  int iftmp.30;
  int D.27877;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.27866 = method->klass;
  D.27867 = D.27866->image;
  D.27868 = D.27867->assembly;
  D.27869 = D.27868->corlib_internal;
  dont_verify = (gboolean) D.27869;
  goto <D.25563>;
  <D.25562>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.25563>:
  D.27870 = BIT_FIELD_REF <*method_definition, 64, 256>;
  D.27871 = D.27870 & 2251799813685248;
  if (D.27871 != 0) goto <D.25562>; else goto <D.25564>;
  <D.25564>:
  if (dont_verify == 0) goto <D.27876>; else goto <D.27874>;
  <D.27876>:
  D.27877 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.27877 != 0) goto <D.27878>; else goto <D.27874>;
  <D.27878>:
  iftmp.30 = 1;
  goto <D.27875>;
  <D.27874>:
  iftmp.30 = 0;
  <D.27875>:
  D.27872 = iftmp.30;
  return D.27872;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  long unsigned int D.27880;
  long unsigned int D.27881;
  gboolean D.27884;
  int D.27885;
  int iftmp.31;
  int D.27892;
  struct MonoDomain * D.27894;
  int D.27895;
  <unnamed-unsigned:1> D.27896;
  int D.27897;
  unsigned char D.27902;
  unsigned int D.27903;
  <unnamed type> D.27909;
  signed char D.27914;
  unsigned int D.27915;
  char * D.27916;
  gchar * D.27917;
  gchar * D.27926;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.27880 = BIT_FIELD_REF <*method, 64, 256>;
  D.27881 = D.27880 & 562949953421312;
  if (D.27881 != 0) goto <D.27882>; else goto <D.27883>;
  <D.27882>:
  D.27884 = 0;
  return D.27884;
  <D.27883>:
  D.27885 = mono_verifier_is_enabled_for_method (method);
  if (D.27885 == 0) goto <D.27886>; else goto <D.27887>;
  <D.27886>:
  D.27884 = 0;
  return D.27884;
  <D.27887>:
  D.27892 = mono_verifier_is_method_full_trust (method);
  if (D.27892 != 0) goto <D.27889>; else goto <D.27893>;
  <D.27893>:
  D.27894 = cfg->domain;
  D.27895 = mini_assembly_can_skip_verification (D.27894, method);
  if (D.27895 != 0) goto <D.27889>; else goto <D.27890>;
  <D.27889>:
  iftmp.31 = 1;
  goto <D.27891>;
  <D.27890>:
  iftmp.31 = 0;
  <D.27891>:
  is_fulltrust = iftmp.31;
  D.27896 = cfg->skip_visibility;
  D.27897 = (int) D.27896;
  res = mono_method_verify_with_current_settings (method, D.27897, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.27898>; else goto <D.27899>;
  <D.27898>:
  if (fail_compile != 0) goto <D.27900>; else goto <D.27901>;
  <D.27900>:
  D.27902 = error->exception_type;
  D.27903 = (unsigned int) D.27902;
  cfg->exception_type = D.27903;
  goto <D.27904>;
  <D.27901>:
  mono_loader_clear_error ();
  <D.27904>:
  if (res != 0B) goto <D.27905>; else goto <D.27906>;
  <D.27905>:
  mono_free_verify_list (res);
  <D.27906>:
  D.27884 = 1;
  return D.27884;
  <D.27899>:
  if (res != 0B) goto <D.27907>; else goto <D.27908>;
  <D.27907>:
  tmp = res;
  goto <D.25552>;
  <D.25551>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.27909 = info->info.status;
    if (D.27909 == 1) goto <D.27910>; else goto <D.27911>;
    <D.27910>:
    if (fail_compile != 0) goto <D.27912>; else goto <D.27913>;
    <D.27912>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27914 = info->exception_type;
      D.27915 = (unsigned int) D.27914;
      cfg->exception_type = D.27915;
      D.27916 = info->info.message;
      D.27917 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27916);
      cfg->exception_message = D.27917;
      monoeg_g_free (method_name);
    }
    <D.27913>:
    mono_free_verify_list (res);
    D.27884 = 1;
    return D.27884;
    <D.27911>:
    D.27909 = info->info.status;
    if (D.27909 == 8) goto <D.27920>; else goto <D.27921>;
    <D.27920>:
    if (is_fulltrust == 0) goto <D.27918>; else goto <D.27922>;
    <D.27922>:
    D.27914 = info->exception_type;
    if (D.27914 == 9) goto <D.27918>; else goto <D.27923>;
    <D.27923>:
    D.27914 = info->exception_type;
    if (D.27914 == 10) goto <D.27918>; else goto <D.27919>;
    <D.27918>:
    if (fail_compile != 0) goto <D.27924>; else goto <D.27925>;
    <D.27924>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.27914 = info->exception_type;
      D.27915 = (unsigned int) D.27914;
      cfg->exception_type = D.27915;
      D.27916 = info->info.message;
      D.27926 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.27916);
      cfg->exception_message = D.27926;
      monoeg_g_free (method_name);
    }
    <D.27925>:
    mono_free_verify_list (res);
    D.27884 = 1;
    return D.27884;
    <D.27919>:
    <D.27921>:
  }
  tmp = tmp->next;
  <D.25552>:
  if (tmp != 0B) goto <D.25551>; else goto <D.25553>;
  <D.25553>:
  mono_free_verify_list (res);
  <D.27908>:
  method->verification_success = 1;
  D.27884 = 0;
  return D.27884;
}


__attribute__((visibility ("hidden")))
mono_icall_get_wrapper (struct MonoJitICallInfo * callinfo)
{
  const void * D.27928;

  D.27928 = mono_icall_get_wrapper_full (callinfo, 0);
  return D.27928;
}


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.27930;
  const void * D.27933;
  const void * D.27934;
  union mono_mutex_t * D.27937;
  _Bool D.27940;
  long int D.27941;
  long int D.27942;
  _Bool D.27949;
  long int D.27950;
  long int D.27951;
  const char * D.27954;
  struct MonoMethodSignature * D.27955;
  const void * D.27956;
  int check_for_pending_exc.32;
  void * D.27961;
  _Bool D.27964;
  long int D.27965;
  long int D.27966;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.27930 = callinfo->wrapper;
  if (D.27930 != 0B) goto <D.27931>; else goto <D.27932>;
  <D.27931>:
  D.27933 = callinfo->wrapper;
  return D.27933;
  <D.27932>:
  D.27934 = callinfo->trampoline;
  if (D.27934 != 0B) goto <D.27935>; else goto <D.27936>;
  <D.27935>:
  D.27933 = callinfo->trampoline;
  return D.27933;
  <D.27936>:
  mono_loader_lock ();
  {
    int ret;

    D.27937 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27937);
    if (ret != 0) goto <D.27938>; else goto <D.27939>;
    <D.27938>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27939>:
    D.27940 = ret != 0;
    D.27941 = (long int) D.27940;
    D.27942 = __builtin_expect (D.27941, 0);
    if (D.27942 != 0) goto <D.27943>; else goto <D.27944>;
    <D.27943>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1697, "ret == 0");
    <D.27944>:
  }
  D.27934 = callinfo->trampoline;
  if (D.27934 != 0B) goto <D.27945>; else goto <D.27946>;
  <D.27945>:
  {
    int ret;

    D.27937 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27937);
    if (ret != 0) goto <D.27947>; else goto <D.27948>;
    <D.27947>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27948>:
    D.27949 = ret != 0;
    D.27950 = (long int) D.27949;
    D.27951 = __builtin_expect (D.27950, 0);
    if (D.27951 != 0) goto <D.27952>; else goto <D.27953>;
    <D.27952>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.27953>:
  }
  mono_loader_unlock ();
  D.27933 = callinfo->trampoline;
  return D.27933;
  <D.27946>:
  D.27954 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.27954);
  D.27955 = callinfo->sig;
  D.27956 = callinfo->func;
  check_for_pending_exc.32 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.27955, name, D.27956, check_for_pending_exc.32);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.27958>; else goto <D.27959>;
  <D.27958>:
  trampoline = mono_compile_method (wrapper);
  goto <D.27960>;
  <D.27959>:
  D.27961 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.27961);
  <D.27960>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.27937 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27937);
    if (ret != 0) goto <D.27962>; else goto <D.27963>;
    <D.27962>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27963>:
    D.27964 = ret != 0;
    D.27965 = (long int) D.27964;
    D.27966 = __builtin_expect (D.27965, 0);
    if (D.27966 != 0) goto <D.27967>; else goto <D.27968>;
    <D.27967>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.27968>:
  }
  mono_loader_unlock ();
  D.27933 = callinfo->trampoline;
  return D.27933;
}


__attribute__((visibility ("hidden")))
mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.27970;
  struct MonoMethodVar * D.27973;
  struct MonoLiveInterval * D.27974;
  gint32 * D.27977;
  struct MonoMemPool * D.27978;
  unsigned int D.27979;
  long unsigned int D.27980;
  long unsigned int D.27981;
  gint32 * D.27982;
  unsigned int i.33;
  unsigned int D.27984;
  struct MonoInst * * D.27985;
  long unsigned int D.27986;
  struct MonoInst * * D.27987;
  long unsigned int D.27988;
  unsigned char D.27991;
  int D.27992;
  int D.27993;
  short unsigned int D.27995;
  unsigned int D.27997;
  long unsigned int D.27998;
  long unsigned int D.27999;
  struct MonoInst * * D.28000;
  struct MonoType * D.28001;
  int D.28002;
  int D.28005;
  int D.28010;
  int D.28012;
  unsigned char D.28014;
  struct MonoClass * D.28016;
  int ialign.34;
  unsigned int ialign.35;
  struct MonoClass * D.28019;
  unsigned char D.28020;
  long unsigned int D.28025;
  long unsigned int D.28026;
  long unsigned int D.28029;
  long unsigned int D.28030;
  int D.28034;
  int D.28035;
  long unsigned int D.28038;
  long unsigned int D.28039;
  struct MonoClass * D.28042;
  long unsigned int D.28043;
  struct StackSlotInfo * D.28044;
  struct MonoClass * D.28045;
  _Bool D.28050;
  long int D.28051;
  long int D.28052;
  long unsigned int D.28055;
  long unsigned int D.28056;
  struct StackSlotInfo * D.28057;
  long unsigned int D.28058;
  long unsigned int D.28061;
  unsigned int D.28066;
  unsigned int D.28067;
  struct GList * D.28070;
  unsigned int D.28071;
  unsigned int D.28072;
  struct GList * D.28074;
  struct GSList * D.28075;
  unsigned int D.28076;
  long unsigned int D.28077;
  long unsigned int D.28078;
  gint32 * D.28079;
  int D.28080;
  long int D.28081;
  void * D.28082;
  struct GSList * D.28083;
  int D.28084;
  void * D.28089;
  long int D.28090;
  struct GSList * D.28091;
  struct GList * D.28092;
  int count.36;
  int count.37;
  int D.28095;
  int D.28102;
  unsigned int align.38;
  unsigned int align.39;
  guint32 iftmp.40;
  struct MonoClass * D.28108;
  int D.28109;
  unsigned int D.28110;
  struct MonoClass * D.28113;
  int D.28114;
  unsigned int size.41;
  unsigned int D.28117;
  unsigned int D.28118;
  unsigned int D.28119;
  unsigned int D.28120;
  unsigned int offset.42;
  unsigned int D.28124;
  unsigned int D.28125;
  unsigned int D.28126;
  unsigned int D.28128;
  unsigned int D.28129;
  long unsigned int D.28130;
  gint32 * D.28131;
  struct StackSlotInfo * D.28132;
  struct GList * D.28133;
  struct GList * D.28136;
  int D.28139;
  int D.28140;
  int i;
  int slot;
  int offset;
  int size;
  guint32 align;
  struct MonoMethodVar * vmv;
  struct MonoInst * inst;
  gint32 * offsets;
  struct GList * vars;
  struct GList * l;
  struct StackSlotInfo * scalar_stack_slots;
  struct StackSlotInfo * vtype_stack_slots;
  struct StackSlotInfo * slot_info;
  struct MonoType * t;
  int nvtypes;
  gboolean reuse_slot;

  try
    {
      vars = 0B;
      D.27970 = cfg->num_varinfo;
      if (D.27970 != 0) goto <D.27971>; else goto <D.27972>;
      <D.27971>:
      D.27973 = cfg->vars;
      D.27974 = D.27973->interval;
      if (D.27974 != 0B) goto <D.27975>; else goto <D.27976>;
      <D.27975>:
      D.27977 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.27977;
      <D.27976>:
      <D.27972>:
      D.27978 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.27978, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.27978 = cfg->mempool;
      D.27970 = cfg->num_varinfo;
      D.27979 = D.27970 * 4;
      offsets = mono_mempool_alloc (D.27978, D.27979);
      i = 0;
      goto <D.25698>;
      <D.25697>:
      D.27980 = (long unsigned int) i;
      D.27981 = D.27980 * 4;
      D.27982 = offsets + D.27981;
      *D.27982 = -1;
      i = i + 1;
      <D.25698>:
      D.27970 = cfg->num_varinfo;
      i.33 = (unsigned int) i;
      if (D.27970 > i.33) goto <D.25697>; else goto <D.25699>;
      <D.25699>:
      D.27984 = cfg->locals_start;
      i = (int) D.27984;
      goto <D.25702>;
      <D.25701>:
      D.27985 = cfg->varinfo;
      D.27980 = (long unsigned int) i;
      D.27986 = D.27980 * 8;
      D.27987 = D.27985 + D.27986;
      inst = *D.27987;
      D.27973 = cfg->vars;
      D.27980 = (long unsigned int) i;
      D.27988 = D.27980 * 80;
      vmv = D.27973 + D.27988;
      D.27991 = inst->flags;
      D.27992 = (int) D.27991;
      D.27993 = D.27992 & 2;
      if (D.27993 != 0) goto <D.27989>; else goto <D.27994>;
      <D.27994>:
      D.27995 = inst->opcode;
      if (D.27995 == 366) goto <D.27989>; else goto <D.27996>;
      <D.27996>:
      D.27995 = inst->opcode;
      if (D.27995 == 367) goto <D.27989>; else goto <D.27990>;
      <D.27989>:
      // predicted unlikely by continue predictor.
      goto <D.25700>;
      <D.27990>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25700>:
      i = i + 1;
      <D.25702>:
      D.27970 = cfg->num_varinfo;
      i.33 = (unsigned int) i;
      if (D.27970 > i.33) goto <D.25701>; else goto <D.25703>;
      <D.25703>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 8;
      l = vars;
      goto <D.25730>;
      <D.25729>:
      vmv = l->data;
      D.27985 = cfg->varinfo;
      D.27997 = vmv->idx;
      D.27998 = (long unsigned int) D.27997;
      D.27999 = D.27998 * 8;
      D.28000 = D.27985 + D.27999;
      inst = *D.28000;
      D.28001 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.28001);
      D.28002 = cfg->gsharedvt;
      if (D.28002 != 0) goto <D.28003>; else goto <D.28004>;
      <D.28003>:
      D.28005 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.28005 != 0) goto <D.28006>; else goto <D.28007>;
      <D.28006>:
      // predicted unlikely by continue predictor.
      goto <D.25704>;
      <D.28007>:
      <D.28004>:
      D.28010 = inst->backend.is_pinvoke;
      if (D.28010 != 0) goto <D.28011>; else goto <D.28008>;
      <D.28011>:
      D.28012 = mono_type_is_struct (t);
      if (D.28012 != 0) goto <D.28013>; else goto <D.28008>;
      <D.28013>:
      D.28014 = t->type;
      if (D.28014 != 22) goto <D.28015>; else goto <D.28008>;
      <D.28015>:
      D.28016 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.28016, &align);
      goto <D.28009>;
      <D.28008>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.34 = ialign;
            ialign.35 = (unsigned int) ialign.34;
            align = ialign.35;
            D.28019 = mono_class_from_mono_type (t);
            D.28020 = D.28019->exception_type;
            if (D.28020 != 0) goto <D.28021>; else goto <D.28022>;
            <D.28021>:
            mono_cfg_set_exception (cfg, 7);
            <D.28022>:
            if (0 != 0) goto <D.28023>; else goto <D.28024>;
            <D.28023>:
            align = 16;
            <D.28024>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.28009>:
      reuse_slot = 1;
      D.28025 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28026 = D.28025 & 32768;
      if (D.28026 != 0) goto <D.28027>; else goto <D.28028>;
      <D.28027>:
      reuse_slot = 0;
      <D.28028>:
      D.28029 = BIT_FIELD_REF <*t, 64, 64>;
      D.28030 = D.28029 & 8589934592;
      if (D.28030 != 0) goto <D.28031>; else goto <D.28032>;
      <D.28031>:
      slot_info = scalar_stack_slots + 768;
      goto <D.28033>;
      <D.28032>:
      D.28014 = t->type;
      D.28034 = (int) D.28014;
      switch (D.28034) <default: <D.25723>, case 10: <D.25715>, case 14: <D.25720>, case 15: <D.25712>, case 17: <D.25708>, case 18: <D.25716>, case 19: <D.25721>, case 20: <D.25718>, case 21: <D.25706>, case 24: <D.25713>, case 25: <D.25714>, case 28: <D.25717>, case 29: <D.25719>, case 30: <D.25722>>
      <D.25706>:
      D.28035 = mono_type_generic_inst_is_valuetype (t);
      if (D.28035 == 0) goto <D.28036>; else goto <D.28037>;
      <D.28036>:
      D.28014 = t->type;
      D.28038 = (long unsigned int) D.28014;
      D.28039 = D.28038 * 32;
      slot_info = scalar_stack_slots + D.28039;
      goto <D.25707>;
      <D.28037>:
      <D.25708>:
      if (vtype_stack_slots == 0B) goto <D.28040>; else goto <D.28041>;
      <D.28040>:
      D.27978 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.27978, 8192);
      <D.28041>:
      i = 0;
      goto <D.25711>;
      <D.25710>:
      D.28042 = t->data.klass;
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      D.28044 = vtype_stack_slots + D.28043;
      D.28045 = D.28044->vtype;
      if (D.28042 == D.28045) goto <D.25709>; else goto <D.28046>;
      <D.28046>:
      i = i + 1;
      <D.25711>:
      if (i < nvtypes) goto <D.25710>; else goto <D.25709>;
      <D.25709>:
      if (i < nvtypes) goto <D.28047>; else goto <D.28048>;
      <D.28047>:
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      slot_info = vtype_stack_slots + D.28043;
      goto <D.28049>;
      <D.28048>:
      D.28050 = nvtypes > 255;
      D.28051 = (long int) D.28050;
      D.28052 = __builtin_expect (D.28051, 0);
      if (D.28052 != 0) goto <D.28053>; else goto <D.28054>;
      <D.28053>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.28054>:
      D.28055 = (long unsigned int) nvtypes;
      D.28056 = D.28055 * 32;
      D.28057 = vtype_stack_slots + D.28056;
      D.28042 = t->data.klass;
      D.28057->vtype = D.28042;
      D.28055 = (long unsigned int) nvtypes;
      D.28056 = D.28055 * 32;
      slot_info = vtype_stack_slots + D.28056;
      nvtypes = nvtypes + 1;
      <D.28049>:
      D.28025 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28058 = D.28025 & 16384;
      if (D.28058 != 0) goto <D.28059>; else goto <D.28060>;
      <D.28059>:
      reuse_slot = 0;
      <D.28060>:
      goto <D.25707>;
      <D.25712>:
      <D.25713>:
      <D.25714>:
      <D.25715>:
      D.28025 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28061 = D.28025 & 8192;
      if (D.28061 != 0) goto <D.28062>; else goto <D.28063>;
      <D.28062>:
      slot_info = scalar_stack_slots + 768;
      goto <D.25707>;
      <D.28063>:
      <D.25716>:
      <D.25717>:
      <D.25718>:
      <D.25719>:
      <D.25720>:
      slot_info = scalar_stack_slots + 576;
      D.28025 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28058 = D.28025 & 16384;
      if (D.28058 != 0) goto <D.28064>; else goto <D.28065>;
      <D.28064>:
      reuse_slot = 0;
      <D.28065>:
      goto <D.25707>;
      <D.25721>:
      <D.25722>:
      D.28014 = t->type;
      D.28038 = (long unsigned int) D.28014;
      D.28039 = D.28038 * 32;
      slot_info = scalar_stack_slots + D.28039;
      goto <D.25707>;
      <D.25723>:
      D.28014 = t->type;
      D.28038 = (long unsigned int) D.28014;
      D.28039 = D.28038 * 32;
      slot_info = scalar_stack_slots + D.28039;
      goto <D.25707>;
      <D.25707>:
      <D.28033>:
      slot = 16777215;
      D.28066 = cfg->comp_done;
      D.28067 = D.28066 & 16;
      if (D.28067 != 0) goto <D.28068>; else goto <D.28069>;
      <D.28068>:
      goto <D.25727>;
      <D.25726>:
      {
        struct MonoMethodVar * amv;

        D.28070 = slot_info->active;
        amv = D.28070->data;
        D.28071 = amv->range.last_use.abs_pos;
        D.28072 = vmv->range.first_use.abs_pos;
        if (D.28071 > D.28072) goto <D.25725>; else goto <D.28073>;
        <D.28073>:
        D.28070 = slot_info->active;
        D.28070 = slot_info->active;
        D.28074 = monoeg_g_list_delete_link (D.28070, D.28070);
        slot_info->active = D.28074;
        D.27978 = cfg->mempool;
        D.28075 = slot_info->slots;
        D.28076 = amv->idx;
        D.28077 = (long unsigned int) D.28076;
        D.28078 = D.28077 * 4;
        D.28079 = offsets + D.28078;
        D.28080 = *D.28079;
        D.28081 = (long int) D.28080;
        D.28082 = (void *) D.28081;
        D.28083 = g_slist_prepend_mempool (D.27978, D.28075, D.28082);
        slot_info->slots = D.28083;
      }
      <D.25727>:
      D.28070 = slot_info->active;
      if (D.28070 != 0B) goto <D.25726>; else goto <D.25725>;
      <D.25725>:
      D.27991 = inst->flags;
      D.27992 = (int) D.27991;
      D.28084 = D.27992 & 20;
      if (D.28084 == 0) goto <D.28085>; else goto <D.28086>;
      <D.28085>:
      D.28075 = slot_info->slots;
      if (D.28075 != 0B) goto <D.28087>; else goto <D.28088>;
      <D.28087>:
      D.28075 = slot_info->slots;
      D.28089 = D.28075->data;
      D.28090 = (long int) D.28089;
      slot = (int) D.28090;
      D.28075 = slot_info->slots;
      D.28091 = D.28075->next;
      slot_info->slots = D.28091;
      <D.28088>:
      D.28070 = slot_info->active;
      D.28092 = mono_varlist_insert_sorted (cfg, D.28070, vmv, 1);
      slot_info->active = D.28092;
      <D.28086>:
      <D.28069>:
      {
        static int count = 0;

        count.36 = count;
        count.37 = count.36 + 1;
        count = count.37;
      }
      D.27991 = inst->flags;
      D.27992 = (int) D.27991;
      D.28095 = D.27992 & 32;
      if (D.28095 != 0) goto <D.28096>; else goto <D.28097>;
      <D.28096>:
      size = 344;
      align = 8;
      reuse_slot = 0;
      <D.28097>:
      if (reuse_slot == 0) goto <D.28098>; else goto <D.28099>;
      <D.28098>:
      slot = 16777215;
      <D.28099>:
      if (slot == 16777215) goto <D.28100>; else goto <D.28101>;
      <D.28100>:
      D.28102 = mono_type_is_struct (t);
      if (D.28102 != 0) goto <D.28103>; else goto <D.28104>;
      <D.28103>:
      align.38 = align;
      align.39 = MAX_EXPR <align.38, 8>;
      align = align.39;
      D.28108 = mono_class_from_mono_type (t);
      D.28109 = mono_class_min_align (D.28108);
      D.28110 = (unsigned int) D.28109;
      align.38 = align;
      if (D.28110 >= align.38) goto <D.28111>; else goto <D.28112>;
      <D.28111>:
      D.28113 = mono_class_from_mono_type (t);
      D.28114 = mono_class_min_align (D.28113);
      iftmp.40 = (guint32) D.28114;
      goto <D.28115>;
      <D.28112>:
      iftmp.40 = align;
      <D.28115>:
      align = iftmp.40;
      align.38 = align;
      size.41 = (unsigned int) size;
      D.28117 = align.38 + size.41;
      D.28118 = D.28117 + 4294967295;
      align.38 = align;
      D.28119 = -align.38;
      D.28120 = D.28118 & D.28119;
      size = (int) D.28120;
      <D.28104>:
      if (backward != 0) goto <D.28121>; else goto <D.28122>;
      <D.28121>:
      offset = offset + size;
      align.38 = align;
      offset.42 = (unsigned int) offset;
      D.28124 = align.38 + offset.42;
      D.28125 = D.28124 + 4294967295;
      offset = (int) D.28125;
      align.38 = align;
      D.28119 = -align.38;
      offset.42 = (unsigned int) offset;
      D.28126 = D.28119 & offset.42;
      offset = (int) D.28126;
      slot = offset;
      goto <D.28127>;
      <D.28122>:
      align.38 = align;
      offset.42 = (unsigned int) offset;
      D.28124 = align.38 + offset.42;
      D.28125 = D.28124 + 4294967295;
      offset = (int) D.28125;
      align.38 = align;
      D.28119 = -align.38;
      offset.42 = (unsigned int) offset;
      D.28126 = D.28119 & offset.42;
      offset = (int) D.28126;
      slot = offset;
      offset = offset + size;
      <D.28127>:
      D.28128 = *stack_align;
      align.38 = align;
      D.28129 = MAX_EXPR <D.28128, align.38>;
      *stack_align = D.28129;
      <D.28101>:
      D.27997 = vmv->idx;
      D.27998 = (long unsigned int) D.27997;
      D.28130 = D.27998 * 4;
      D.28131 = offsets + D.28130;
      *D.28131 = slot;
      <D.25704>:
      l = l->next;
      <D.25730>:
      if (l != 0B) goto <D.25729>; else goto <D.25731>;
      <D.25731>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25733>;
      <D.25732>:
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      D.28132 = scalar_stack_slots + D.28043;
      D.28133 = D.28132->active;
      if (D.28133 != 0B) goto <D.28134>; else goto <D.28135>;
      <D.28134>:
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      D.28132 = scalar_stack_slots + D.28043;
      D.28133 = D.28132->active;
      monoeg_g_list_free (D.28133);
      <D.28135>:
      i = i + 1;
      <D.25733>:
      if (i <= 68) goto <D.25732>; else goto <D.25734>;
      <D.25734>:
      i = 0;
      goto <D.25736>;
      <D.25735>:
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      D.28044 = vtype_stack_slots + D.28043;
      D.28136 = D.28044->active;
      if (D.28136 != 0B) goto <D.28137>; else goto <D.28138>;
      <D.28137>:
      D.27980 = (long unsigned int) i;
      D.28043 = D.27980 * 32;
      D.28044 = vtype_stack_slots + D.28043;
      D.28136 = D.28044->active;
      monoeg_g_list_free (D.28136);
      <D.28138>:
      i = i + 1;
      <D.25736>:
      if (i < nvtypes) goto <D.25735>; else goto <D.25737>;
      <D.25737>:
      D.28139 = cfg->stat_locals_stack_size;
      D.28140 = D.28139 + offset;
      cfg->stat_locals_stack_size = D.28140;
      offset.42 = (unsigned int) offset;
      *stack_size = offset.42;
      D.27977 = offsets;
      return D.27977;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.28143;
  unsigned int D.28144;
  unsigned int D.28145;
  long unsigned int D.28146;
  long unsigned int D.28147;
  gint32 * D.28148;
  unsigned int i.43;
  unsigned int D.28150;
  struct MonoInst * * D.28151;
  long unsigned int D.28152;
  struct MonoInst * * D.28153;
  struct MonoMethodVar * D.28154;
  long unsigned int D.28155;
  unsigned char D.28158;
  int D.28159;
  int D.28160;
  short unsigned int D.28162;
  struct GList * D.28164;
  unsigned int D.28165;
  long unsigned int D.28166;
  long unsigned int D.28167;
  struct MonoInst * * D.28168;
  struct MonoType * D.28169;
  int D.28170;
  int D.28173;
  int D.28178;
  int D.28180;
  unsigned char D.28182;
  struct MonoClass * D.28184;
  int ialign.44;
  unsigned int ialign.45;
  long unsigned int D.28189;
  long unsigned int D.28190;
  int D.28193;
  int D.28194;
  long unsigned int D.28197;
  long unsigned int D.28198;
  struct MonoClass * D.28201;
  long unsigned int D.28202;
  struct StackSlotInfo * D.28203;
  struct MonoClass * D.28204;
  _Bool D.28209;
  long int D.28210;
  long int D.28211;
  long unsigned int D.28214;
  long unsigned int D.28215;
  struct StackSlotInfo * D.28216;
  long unsigned int D.28217;
  long unsigned int D.28220;
  unsigned int D.28225;
  unsigned int D.28226;
  struct MonoLiveInterval * D.28229;
  struct MonoLiveRange2 * D.28230;
  int D.28233;
  unsigned char D.28237;
  struct MonoLiveInterval * D.28241;
  struct MonoLiveRange2 * D.28242;
  int D.28243;
  struct GList * D.28246;
  struct GList * D.28247;
  struct GSList * D.28248;
  unsigned int D.28249;
  long unsigned int D.28250;
  long unsigned int D.28251;
  gint32 * D.28252;
  int D.28253;
  long int D.28254;
  void * D.28255;
  struct GSList * D.28256;
  int D.28257;
  struct GList * D.28260;
  struct GList * D.28261;
  struct GList * D.28262;
  struct MonoLiveInterval * D.28263;
  struct MonoLiveRange2 * D.28264;
  int D.28265;
  struct GList * D.28268;
  int D.28269;
  struct GList * D.28272;
  struct GList * D.28273;
  void * D.28278;
  long int D.28279;
  struct GSList * D.28280;
  struct GList * D.28281;
  int D.28282;
  int D.28289;
  unsigned int align.46;
  unsigned int align.47;
  guint32 iftmp.48;
  struct MonoClass * D.28295;
  int D.28296;
  unsigned int D.28297;
  struct MonoClass * D.28300;
  int D.28301;
  unsigned int offset.49;
  unsigned int D.28306;
  unsigned int D.28307;
  unsigned int D.28308;
  unsigned int D.28309;
  unsigned int D.28311;
  long unsigned int D.28314;
  gint32 * D.28315;
  struct StackSlotInfo * D.28316;
  struct GList * D.28317;
  struct GList * D.28320;
  int D.28323;
  int D.28324;
  gint32 * D.28325;
  int i;
  int slot;
  int offset;
  int size;
  guint32 align;
  struct MonoMethodVar * vmv;
  struct MonoInst * inst;
  gint32 * offsets;
  struct GList * vars;
  struct GList * l;
  struct GList * unhandled;
  struct StackSlotInfo * scalar_stack_slots;
  struct StackSlotInfo * vtype_stack_slots;
  struct StackSlotInfo * slot_info;
  struct MonoType * t;
  int nvtypes;
  gboolean reuse_slot;

  try
    {
      vars = 0B;
      D.28143 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.28143, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.28143 = cfg->mempool;
      D.28144 = cfg->num_varinfo;
      D.28145 = D.28144 * 4;
      offsets = mono_mempool_alloc (D.28143, D.28145);
      i = 0;
      goto <D.25625>;
      <D.25624>:
      D.28146 = (long unsigned int) i;
      D.28147 = D.28146 * 4;
      D.28148 = offsets + D.28147;
      *D.28148 = -1;
      i = i + 1;
      <D.25625>:
      D.28144 = cfg->num_varinfo;
      i.43 = (unsigned int) i;
      if (D.28144 > i.43) goto <D.25624>; else goto <D.25626>;
      <D.25626>:
      D.28150 = cfg->locals_start;
      i = (int) D.28150;
      goto <D.25629>;
      <D.25628>:
      D.28151 = cfg->varinfo;
      D.28146 = (long unsigned int) i;
      D.28152 = D.28146 * 8;
      D.28153 = D.28151 + D.28152;
      inst = *D.28153;
      D.28154 = cfg->vars;
      D.28146 = (long unsigned int) i;
      D.28155 = D.28146 * 80;
      vmv = D.28154 + D.28155;
      D.28158 = inst->flags;
      D.28159 = (int) D.28158;
      D.28160 = D.28159 & 2;
      if (D.28160 != 0) goto <D.28156>; else goto <D.28161>;
      <D.28161>:
      D.28162 = inst->opcode;
      if (D.28162 == 366) goto <D.28156>; else goto <D.28163>;
      <D.28163>:
      D.28162 = inst->opcode;
      if (D.28162 == 367) goto <D.28156>; else goto <D.28157>;
      <D.28156>:
      // predicted unlikely by continue predictor.
      goto <D.25627>;
      <D.28157>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25627>:
      i = i + 1;
      <D.25629>:
      D.28144 = cfg->num_varinfo;
      i.43 = (unsigned int) i;
      if (D.28144 > i.43) goto <D.25628>; else goto <D.25630>;
      <D.25630>:
      D.28164 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.28164, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.25667>;
      <D.25666>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.28151 = cfg->varinfo;
        D.28165 = vmv->idx;
        D.28166 = (long unsigned int) D.28165;
        D.28167 = D.28166 * 8;
        D.28168 = D.28151 + D.28167;
        inst = *D.28168;
        D.28169 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.28169);
        D.28170 = cfg->gsharedvt;
        if (D.28170 != 0) goto <D.28171>; else goto <D.28172>;
        <D.28171>:
        D.28173 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.28173 != 0) goto <D.28174>; else goto <D.28175>;
        <D.28174>:
        // predicted unlikely by continue predictor.
        goto <D.25632>;
        <D.28175>:
        <D.28172>:
        D.28178 = inst->backend.is_pinvoke;
        if (D.28178 != 0) goto <D.28179>; else goto <D.28176>;
        <D.28179>:
        D.28180 = mono_type_is_struct (t);
        if (D.28180 != 0) goto <D.28181>; else goto <D.28176>;
        <D.28181>:
        D.28182 = t->type;
        if (D.28182 != 22) goto <D.28183>; else goto <D.28176>;
        <D.28183>:
        D.28184 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.28184, &align);
        goto <D.28177>;
        <D.28176>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.44 = ialign;
              ialign.45 = (unsigned int) ialign.44;
              align = ialign.45;
              if (0 != 0) goto <D.28187>; else goto <D.28188>;
              <D.28187>:
              align = 16;
              <D.28188>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.28177>:
        reuse_slot = 1;
        D.28189 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28190 = D.28189 & 32768;
        if (D.28190 != 0) goto <D.28191>; else goto <D.28192>;
        <D.28191>:
        reuse_slot = 0;
        <D.28192>:
        D.28182 = t->type;
        D.28193 = (int) D.28182;
        switch (D.28193) <default: <D.25649>, case 10: <D.25643>, case 14: <D.25648>, case 15: <D.25640>, case 17: <D.25636>, case 18: <D.25644>, case 20: <D.25646>, case 21: <D.25634>, case 24: <D.25641>, case 25: <D.25642>, case 28: <D.25645>, case 29: <D.25647>>
        <D.25634>:
        D.28194 = mono_type_generic_inst_is_valuetype (t);
        if (D.28194 == 0) goto <D.28195>; else goto <D.28196>;
        <D.28195>:
        D.28182 = t->type;
        D.28197 = (long unsigned int) D.28182;
        D.28198 = D.28197 * 32;
        slot_info = scalar_stack_slots + D.28198;
        goto <D.25635>;
        <D.28196>:
        <D.25636>:
        if (vtype_stack_slots == 0B) goto <D.28199>; else goto <D.28200>;
        <D.28199>:
        D.28143 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.28143, 8192);
        <D.28200>:
        i = 0;
        goto <D.25639>;
        <D.25638>:
        D.28201 = t->data.klass;
        D.28146 = (long unsigned int) i;
        D.28202 = D.28146 * 32;
        D.28203 = vtype_stack_slots + D.28202;
        D.28204 = D.28203->vtype;
        if (D.28201 == D.28204) goto <D.25637>; else goto <D.28205>;
        <D.28205>:
        i = i + 1;
        <D.25639>:
        if (i < nvtypes) goto <D.25638>; else goto <D.25637>;
        <D.25637>:
        if (i < nvtypes) goto <D.28206>; else goto <D.28207>;
        <D.28206>:
        D.28146 = (long unsigned int) i;
        D.28202 = D.28146 * 32;
        slot_info = vtype_stack_slots + D.28202;
        goto <D.28208>;
        <D.28207>:
        D.28209 = nvtypes > 255;
        D.28210 = (long int) D.28209;
        D.28211 = __builtin_expect (D.28210, 0);
        if (D.28211 != 0) goto <D.28212>; else goto <D.28213>;
        <D.28212>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.28213>:
        D.28214 = (long unsigned int) nvtypes;
        D.28215 = D.28214 * 32;
        D.28216 = vtype_stack_slots + D.28215;
        D.28201 = t->data.klass;
        D.28216->vtype = D.28201;
        D.28214 = (long unsigned int) nvtypes;
        D.28215 = D.28214 * 32;
        slot_info = vtype_stack_slots + D.28215;
        nvtypes = nvtypes + 1;
        <D.28208>:
        D.28189 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28217 = D.28189 & 16384;
        if (D.28217 != 0) goto <D.28218>; else goto <D.28219>;
        <D.28218>:
        reuse_slot = 0;
        <D.28219>:
        goto <D.25635>;
        <D.25640>:
        <D.25641>:
        <D.25642>:
        <D.25643>:
        D.28189 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28220 = D.28189 & 8192;
        if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
        <D.28221>:
        slot_info = scalar_stack_slots + 768;
        goto <D.25635>;
        <D.28222>:
        <D.25644>:
        <D.25645>:
        <D.25646>:
        <D.25647>:
        <D.25648>:
        slot_info = scalar_stack_slots + 576;
        D.28189 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28217 = D.28189 & 16384;
        if (D.28217 != 0) goto <D.28223>; else goto <D.28224>;
        <D.28223>:
        reuse_slot = 0;
        <D.28224>:
        goto <D.25635>;
        <D.25649>:
        D.28182 = t->type;
        D.28197 = (long unsigned int) D.28182;
        D.28198 = D.28197 * 32;
        slot_info = scalar_stack_slots + D.28198;
        <D.25635>:
        slot = 16777215;
        D.28225 = cfg->comp_done;
        D.28226 = D.28225 & 16;
        if (D.28226 != 0) goto <D.28227>; else goto <D.28228>;
        <D.28227>:
        {
          int pos;
          gboolean changed;

          D.28229 = current->interval;
          D.28230 = D.28229->range;
          if (D.28230 == 0B) goto <D.28231>; else goto <D.28232>;
          <D.28231>:
          D.28158 = inst->flags;
          D.28159 = (int) D.28158;
          D.28233 = D.28159 & 20;
          if (D.28233 != 0) goto <D.28234>; else goto <D.28235>;
          <D.28234>:
          pos = -1;
          goto <D.28236>;
          <D.28235>:
          D.28158 = inst->flags;
          D.28237 = D.28158 | 2;
          inst->flags = D.28237;
          // predicted unlikely by continue predictor.
          goto <D.25632>;
          <D.28236>:
          goto <D.28238>;
          <D.28232>:
          D.28229 = current->interval;
          D.28230 = D.28229->range;
          pos = D.28230->from;
          <D.28238>:
          D.28229 = current->interval;
          D.28230 = D.28229->range;
          if (D.28230 != 0B) goto <D.28239>; else goto <D.28240>;
          <D.28239>:
          <D.28240>:
          changed = 1;
          goto <D.25657>;
          <D.25656>:
          changed = 0;
          l = slot_info->active;
          goto <D.25655>;
          <D.25654>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28241 = v->interval;
            D.28242 = D.28241->last_range;
            D.28243 = D.28242->to;
            if (D.28243 < pos) goto <D.28244>; else goto <D.28245>;
            <D.28244>:
            D.28246 = slot_info->active;
            D.28247 = monoeg_g_list_delete_link (D.28246, l);
            slot_info->active = D.28247;
            D.28143 = cfg->mempool;
            D.28248 = slot_info->slots;
            D.28249 = v->idx;
            D.28250 = (long unsigned int) D.28249;
            D.28251 = D.28250 * 4;
            D.28252 = offsets + D.28251;
            D.28253 = *D.28252;
            D.28254 = (long int) D.28253;
            D.28255 = (void *) D.28254;
            D.28256 = g_slist_prepend_mempool (D.28143, D.28248, D.28255);
            slot_info->slots = D.28256;
            changed = 1;
            goto <D.25653>;
            <D.28245>:
            D.28241 = v->interval;
            D.28257 = mono_linterval_covers (D.28241, pos);
            if (D.28257 == 0) goto <D.28258>; else goto <D.28259>;
            <D.28258>:
            D.28260 = slot_info->inactive;
            D.28261 = monoeg_g_list_append (D.28260, v);
            slot_info->inactive = D.28261;
            D.28246 = slot_info->active;
            D.28262 = monoeg_g_list_delete_link (D.28246, l);
            slot_info->active = D.28262;
            changed = 1;
            goto <D.25653>;
            <D.28259>:
          }
          l = l->next;
          <D.25655>:
          if (l != 0B) goto <D.25654>; else goto <D.25653>;
          <D.25653>:
          <D.25657>:
          if (changed != 0) goto <D.25656>; else goto <D.25658>;
          <D.25658>:
          changed = 1;
          goto <D.25664>;
          <D.25663>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.25662>;
          <D.25661>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28263 = v->interval;
            D.28264 = D.28263->last_range;
            D.28265 = D.28264->to;
            if (D.28265 < pos) goto <D.28266>; else goto <D.28267>;
            <D.28266>:
            D.28260 = slot_info->inactive;
            D.28268 = monoeg_g_list_delete_link (D.28260, l);
            slot_info->inactive = D.28268;
            changed = 1;
            goto <D.25660>;
            <D.28267>:
            D.28263 = v->interval;
            D.28269 = mono_linterval_covers (D.28263, pos);
            if (D.28269 != 0) goto <D.28270>; else goto <D.28271>;
            <D.28270>:
            D.28246 = slot_info->active;
            D.28272 = monoeg_g_list_append (D.28246, v);
            slot_info->active = D.28272;
            D.28260 = slot_info->inactive;
            D.28273 = monoeg_g_list_delete_link (D.28260, l);
            slot_info->inactive = D.28273;
            changed = 1;
            goto <D.25660>;
            <D.28271>:
          }
          l = l->next;
          <D.25662>:
          if (l != 0B) goto <D.25661>; else goto <D.25660>;
          <D.25660>:
          <D.25664>:
          if (changed != 0) goto <D.25663>; else goto <D.25665>;
          <D.25665>:
          D.28158 = inst->flags;
          D.28159 = (int) D.28158;
          D.28233 = D.28159 & 20;
          if (D.28233 == 0) goto <D.28274>; else goto <D.28275>;
          <D.28274>:
          D.28248 = slot_info->slots;
          if (D.28248 != 0B) goto <D.28276>; else goto <D.28277>;
          <D.28276>:
          D.28248 = slot_info->slots;
          D.28278 = D.28248->data;
          D.28279 = (long int) D.28278;
          slot = (int) D.28279;
          D.28248 = slot_info->slots;
          D.28280 = D.28248->next;
          slot_info->slots = D.28280;
          <D.28277>:
          D.28246 = slot_info->active;
          D.28281 = mono_varlist_insert_sorted (cfg, D.28246, vmv, 1);
          slot_info->active = D.28281;
          <D.28275>:
        }
        <D.28228>:
        D.28158 = inst->flags;
        D.28159 = (int) D.28158;
        D.28282 = D.28159 & 32;
        if (D.28282 != 0) goto <D.28283>; else goto <D.28284>;
        <D.28283>:
        size = 344;
        align = 8;
        reuse_slot = 0;
        <D.28284>:
        if (reuse_slot == 0) goto <D.28285>; else goto <D.28286>;
        <D.28285>:
        slot = 16777215;
        <D.28286>:
        if (slot == 16777215) goto <D.28287>; else goto <D.28288>;
        <D.28287>:
        D.28289 = mono_type_is_struct (t);
        if (D.28289 != 0) goto <D.28290>; else goto <D.28291>;
        <D.28290>:
        align.46 = align;
        align.47 = MAX_EXPR <align.46, 8>;
        align = align.47;
        D.28295 = mono_class_from_mono_type (t);
        D.28296 = mono_class_min_align (D.28295);
        D.28297 = (unsigned int) D.28296;
        align.46 = align;
        if (D.28297 >= align.46) goto <D.28298>; else goto <D.28299>;
        <D.28298>:
        D.28300 = mono_class_from_mono_type (t);
        D.28301 = mono_class_min_align (D.28300);
        iftmp.48 = (guint32) D.28301;
        goto <D.28302>;
        <D.28299>:
        iftmp.48 = align;
        <D.28302>:
        align = iftmp.48;
        <D.28291>:
        if (backward != 0) goto <D.28303>; else goto <D.28304>;
        <D.28303>:
        offset = offset + size;
        align.46 = align;
        offset.49 = (unsigned int) offset;
        D.28306 = align.46 + offset.49;
        D.28307 = D.28306 + 4294967295;
        offset = (int) D.28307;
        align.46 = align;
        D.28308 = -align.46;
        offset.49 = (unsigned int) offset;
        D.28309 = D.28308 & offset.49;
        offset = (int) D.28309;
        slot = offset;
        goto <D.28310>;
        <D.28304>:
        align.46 = align;
        offset.49 = (unsigned int) offset;
        D.28306 = align.46 + offset.49;
        D.28307 = D.28306 + 4294967295;
        offset = (int) D.28307;
        align.46 = align;
        D.28308 = -align.46;
        offset.49 = (unsigned int) offset;
        D.28309 = D.28308 & offset.49;
        offset = (int) D.28309;
        slot = offset;
        offset = offset + size;
        <D.28310>:
        D.28311 = *stack_align;
        if (D.28311 == 0) goto <D.28312>; else goto <D.28313>;
        <D.28312>:
        align.46 = align;
        *stack_align = align.46;
        <D.28313>:
        <D.28288>:
        D.28165 = vmv->idx;
        D.28166 = (long unsigned int) D.28165;
        D.28314 = D.28166 * 4;
        D.28315 = offsets + D.28314;
        *D.28315 = slot;
      }
      <D.25632>:
      unhandled = unhandled->next;
      <D.25667>:
      if (unhandled != 0B) goto <D.25666>; else goto <D.25668>;
      <D.25668>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25670>;
      <D.25669>:
      D.28146 = (long unsigned int) i;
      D.28202 = D.28146 * 32;
      D.28316 = scalar_stack_slots + D.28202;
      D.28317 = D.28316->active;
      if (D.28317 != 0B) goto <D.28318>; else goto <D.28319>;
      <D.28318>:
      D.28146 = (long unsigned int) i;
      D.28202 = D.28146 * 32;
      D.28316 = scalar_stack_slots + D.28202;
      D.28317 = D.28316->active;
      monoeg_g_list_free (D.28317);
      <D.28319>:
      i = i + 1;
      <D.25670>:
      if (i <= 68) goto <D.25669>; else goto <D.25671>;
      <D.25671>:
      i = 0;
      goto <D.25673>;
      <D.25672>:
      D.28146 = (long unsigned int) i;
      D.28202 = D.28146 * 32;
      D.28203 = vtype_stack_slots + D.28202;
      D.28320 = D.28203->active;
      if (D.28320 != 0B) goto <D.28321>; else goto <D.28322>;
      <D.28321>:
      D.28146 = (long unsigned int) i;
      D.28202 = D.28146 * 32;
      D.28203 = vtype_stack_slots + D.28202;
      D.28320 = D.28203->active;
      monoeg_g_list_free (D.28320);
      <D.28322>:
      i = i + 1;
      <D.25673>:
      if (i < nvtypes) goto <D.25672>; else goto <D.25674>;
      <D.25674>:
      D.28323 = cfg->stat_locals_stack_size;
      D.28324 = D.28323 + offset;
      cfg->stat_locals_stack_size = D.28324;
      offset.49 = (unsigned int) offset;
      *stack_size = offset.49;
      D.28325 = offsets;
      return D.28325;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.28330;
  struct MonoLiveInterval * D.28332;
  struct MonoLiveRange2 * D.28333;
  struct MonoLiveInterval * D.28335;
  struct MonoLiveRange2 * D.28336;
  int D.28338;
  int D.28339;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.28328>; else goto <D.28329>;
  <D.28328>:
  D.28330 = 0;
  return D.28330;
  <D.28329>:
  D.28332 = v1->interval;
  D.28333 = D.28332->range;
  if (D.28333 != 0B) goto <D.28334>; else goto <D.28331>;
  <D.28334>:
  D.28335 = v2->interval;
  D.28336 = D.28335->range;
  if (D.28336 != 0B) goto <D.28337>; else goto <D.28331>;
  <D.28337>:
  D.28332 = v1->interval;
  D.28333 = D.28332->range;
  D.28338 = D.28333->from;
  D.28335 = v2->interval;
  D.28336 = D.28335->range;
  D.28339 = D.28336->from;
  D.28330 = D.28338 - D.28339;
  return D.28330;
  <D.28331>:
  D.28332 = v1->interval;
  D.28333 = D.28332->range;
  if (D.28333 != 0B) goto <D.28340>; else goto <D.28341>;
  <D.28340>:
  D.28330 = -1;
  return D.28330;
  <D.28341>:
  D.28330 = 1;
  return D.28330;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.28343;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = list;
  D.28343 = new_list;
  return D.28343;
}


__attribute__((visibility ("hidden")))
mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.50;
  _Bool D.28346;
  long int D.28347;
  long int D.28348;
  int D.28351;
  unsigned char D.28352;
  int D.28353;
  int D.28354;
  int D.28355;
  int D.28356;
  short int * emul_opcode_opcodes.51;
  long unsigned int D.28360;
  long unsigned int D.28361;
  short int * D.28362;
  short int D.28363;
  int D.28364;
  struct MonoJitICallInfo * D.28367;
  struct MonoJitICallInfo * * emul_opcode_map.52;
  long unsigned int D.28369;
  struct MonoJitICallInfo * * D.28370;
  short int emul_opcode_num.53;
  int D.28372;

  opcode.50 = (unsigned int) opcode;
  D.28346 = opcode.50 > 861;
  D.28347 = (long int) D.28346;
  D.28348 = __builtin_expect (D.28347, 0);
  if (D.28348 != 0) goto <D.28349>; else goto <D.28350>;
  <D.28349>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2356, "opcode >= 0 && opcode <= OP_LAST");
  <D.28350>:
  D.28351 = opcode >> 6;
  D.28352 = emul_opcode_hit_cache[D.28351];
  D.28353 = (int) D.28352;
  D.28354 = opcode & 7;
  D.28355 = D.28353 >> D.28354;
  D.28356 = D.28355 & 1;
  if (D.28356 != 0) goto <D.28357>; else goto <D.28358>;
  <D.28357>:
  {
    int i;

    i = 0;
    goto <D.25748>;
    <D.25747>:
    emul_opcode_opcodes.51 = emul_opcode_opcodes;
    D.28360 = (long unsigned int) i;
    D.28361 = D.28360 * 2;
    D.28362 = emul_opcode_opcodes.51 + D.28361;
    D.28363 = *D.28362;
    D.28364 = (int) D.28363;
    if (D.28364 == opcode) goto <D.28365>; else goto <D.28366>;
    <D.28365>:
    emul_opcode_map.52 = emul_opcode_map;
    D.28360 = (long unsigned int) i;
    D.28369 = D.28360 * 8;
    D.28370 = emul_opcode_map.52 + D.28369;
    D.28367 = *D.28370;
    return D.28367;
    <D.28366>:
    i = i + 1;
    <D.25748>:
    emul_opcode_num.53 = emul_opcode_num;
    D.28372 = (int) emul_opcode_num.53;
    if (D.28372 > i) goto <D.25747>; else goto <D.25749>;
    <D.25749>:
  }
  <D.28358>:
  D.28367 = 0B;
  return D.28367;
}


__attribute__((visibility ("hidden")))
mono_bblock_add_inst (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.28374;

  D.28374 = bb->last_ins;
  if (D.28374 != 0B) goto <D.28375>; else goto <D.28376>;
  <D.28375>:
  D.28374 = bb->last_ins;
  D.28374->next = inst;
  D.28374 = bb->last_ins;
  inst->prev = D.28374;
  bb->last_ins = inst;
  goto <D.28377>;
  <D.28376>:
  bb->last_ins = inst;
  D.28374 = bb->last_ins;
  bb->code = D.28374;
  <D.28377>:
}


__attribute__((visibility ("hidden")))
mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28382;
  struct MonoInst * D.28386;

  if (ins == 0B) goto <D.28378>; else goto <D.28379>;
  <D.28378>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.28380>; else goto <D.28381>;
  <D.28380>:
  ins->prev = ins_to_insert;
  <D.28381>:
  D.28382 = bb->last_ins;
  if (D.28382 == 0B) goto <D.28383>; else goto <D.28384>;
  <D.28383>:
  bb->last_ins = ins_to_insert;
  <D.28384>:
  goto <D.28385>;
  <D.28379>:
  D.28386 = ins->next;
  ins_to_insert->next = D.28386;
  D.28386 = ins->next;
  if (D.28386 != 0B) goto <D.28387>; else goto <D.28388>;
  <D.28387>:
  D.28386 = ins->next;
  D.28386->prev = ins_to_insert;
  <D.28388>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.28382 = bb->last_ins;
  if (D.28382 == ins) goto <D.28389>; else goto <D.28390>;
  <D.28389>:
  bb->last_ins = ins_to_insert;
  <D.28390>:
  <D.28385>:
}


__attribute__((visibility ("hidden")))
mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28395;
  struct MonoInst * D.28399;
  struct MonoInst * D.28402;

  if (ins == 0B) goto <D.28391>; else goto <D.28392>;
  <D.28391>:
  ins = bb->code;
  if (ins != 0B) goto <D.28393>; else goto <D.28394>;
  <D.28393>:
  ins->prev = ins_to_insert;
  <D.28394>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.28395 = bb->last_ins;
  if (D.28395 == 0B) goto <D.28396>; else goto <D.28397>;
  <D.28396>:
  bb->last_ins = ins_to_insert;
  <D.28397>:
  goto <D.28398>;
  <D.28392>:
  D.28399 = ins->prev;
  if (D.28399 != 0B) goto <D.28400>; else goto <D.28401>;
  <D.28400>:
  D.28399 = ins->prev;
  D.28399->next = ins_to_insert;
  <D.28401>:
  D.28399 = ins->prev;
  ins_to_insert->prev = D.28399;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.28402 = bb->code;
  if (D.28402 == ins) goto <D.28403>; else goto <D.28404>;
  <D.28403>:
  bb->code = ins_to_insert;
  <D.28404>:
  <D.28398>:
}


__attribute__((visibility ("hidden")))
mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.28405;
  _Bool D.28406;
  long int D.28407;
  long int D.28408;
  struct MonoInst * D.28411;
  struct MonoInst * D.28414;
  _Bool D.28415;
  long int D.28416;
  long int D.28417;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.25816>;
  <D.25815>:
  D.28405 = ins->prev;
  D.28406 = D.28405 != prev;
  D.28407 = (long int) D.28406;
  D.28408 = __builtin_expect (D.28407, 0);
  if (D.28408 != 0) goto <D.28409>; else goto <D.28410>;
  <D.28409>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.28410>:
  prev = ins;
  ins = ins->next;
  <D.25816>:
  if (ins != 0B) goto <D.25815>; else goto <D.25817>;
  <D.25817>:
  D.28411 = bb->last_ins;
  if (D.28411 != 0B) goto <D.28412>; else goto <D.28413>;
  <D.28412>:
  D.28411 = bb->last_ins;
  D.28414 = D.28411->next;
  D.28415 = D.28414 != 0B;
  D.28416 = (long int) D.28415;
  D.28417 = __builtin_expect (D.28416, 0);
  if (D.28417 != 0) goto <D.28418>; else goto <D.28419>;
  <D.28418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.28419>:
  <D.28413>:
}


__attribute__((visibility ("hidden")))
mono_verify_cfg (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.25823>;
  <D.25822>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.25823>:
  if (bb != 0B) goto <D.25822>; else goto <D.25824>;
  <D.25824>:
}


__attribute__((visibility ("hidden")))
mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.28420;
  struct MonoRegState * D.28423;
  struct GHashTable * D.28426;
  struct GHashTable * D.28429;
  void * D.28432;
  struct GList * D.28433;
  struct GHashTable * D.28434;
  struct GHashTable * D.28435;
  struct MonoMemPool * D.28438;
  struct MonoInst * * D.28439;
  struct MonoMethodVar * D.28440;
  char * D.28441;
  struct GSList * l;

  D.28420 = cfg->header;
  if (D.28420 != 0B) goto <D.28421>; else goto <D.28422>;
  <D.28421>:
  D.28420 = cfg->header;
  mono_metadata_free_mh (D.28420);
  <D.28422>:
  mono_free_loop_info (cfg);
  D.28423 = cfg->rs;
  if (D.28423 != 0B) goto <D.28424>; else goto <D.28425>;
  <D.28424>:
  D.28423 = cfg->rs;
  mono_regstate_free (D.28423);
  <D.28425>:
  D.28426 = cfg->spvars;
  if (D.28426 != 0B) goto <D.28427>; else goto <D.28428>;
  <D.28427>:
  D.28426 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.28426);
  <D.28428>:
  D.28429 = cfg->exvars;
  if (D.28429 != 0B) goto <D.28430>; else goto <D.28431>;
  <D.28430>:
  D.28429 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.28429);
  <D.28431>:
  l = cfg->headers_to_free;
  goto <D.25830>;
  <D.25829>:
  D.28432 = l->data;
  mono_metadata_free_mh (D.28432);
  l = l->next;
  <D.25830>:
  if (l != 0B) goto <D.25829>; else goto <D.25831>;
  <D.25831>:
  D.28433 = cfg->ldstr_list;
  monoeg_g_list_free (D.28433);
  D.28434 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.28434);
  D.28435 = cfg->abs_patches;
  if (D.28435 != 0B) goto <D.28436>; else goto <D.28437>;
  <D.28436>:
  D.28435 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.28435);
  <D.28437>:
  D.28438 = cfg->mempool;
  mono_mempool_destroy (D.28438);
  mono_debug_free_method (cfg);
  D.28439 = cfg->varinfo;
  monoeg_g_free (D.28439);
  D.28440 = cfg->vars;
  monoeg_g_free (D.28440);
  D.28441 = cfg->exception_message;
  monoeg_g_free (D.28441);
  monoeg_g_free (cfg);
}


__attribute__((visibility ("hidden")))
mono_get_jit_tls_key ()
{
  pthread_key_t D.28442;

  D.28442 = mono_jit_tls_id;
  return D.28442;
}


__attribute__((visibility ("hidden")))
mono_get_jit_tls_offset ()
{
  gint32 D.28444;
  int offset;

  {
    guint64 foo;

    __asm__("basr	%%r1,0
	j	0f
	.quad mono_jit_tls@NTPOFF
0:
	lg	%0,4(%%r1)
	" : "=r" foo :  : "1");
    offset = (int) foo;
  }
  D.28444 = offset;
  return D.28444;
}


__attribute__((visibility ("hidden")))
mono_get_lmf_tls_offset ()
{
  gint32 D.28446;
  int offset;

  {
    guint64 foo;

    __asm__("basr	%%r1,0
	j	0f
	.quad mono_lmf@NTPOFF
0:
	lg	%0,4(%%r1)
	" : "=r" foo :  : "1");
    offset = (int) foo;
  }
  D.28446 = offset;
  return D.28446;
}


__attribute__((visibility ("hidden")))
mono_get_lmf_addr_tls_offset ()
{
  gint32 D.28448;
  int offset;

  {
    guint64 foo;

    __asm__("basr	%%r1,0
	j	0f
	.quad mono_lmf_addr@NTPOFF
0:
	lg	%0,4(%%r1)
	" : "=r" foo :  : "1");
    offset = (int) foo;
  }
  D.28448 = offset;
  return D.28448;
}


__attribute__((visibility ("hidden")))
mono_get_lmf ()
{
  struct MonoLMF * D.28450;

  D.28450 = mono_lmf;
  return D.28450;
}


__attribute__((visibility ("hidden")))
mono_get_lmf_addr ()
{
  struct MonoLMF * * D.28452;

  D.28452 = mono_lmf_addr;
  return D.28452;
}


__attribute__((visibility ("hidden")))
mono_set_lmf (struct MonoLMF * lmf)
{
  struct MonoLMF * * D.28454;

  mono_lmf = lmf;
  D.28454 = mono_get_lmf_addr ();
  *D.28454 = lmf;
}


mono_jit_thread_attach (struct MonoDomain * domain)
{
  void * mono_lmf_addr.54;
  struct MonoInternalThread * D.28460;
  struct MonoDomain * D.28463;
  struct MonoDomain * iftmp.55;
  struct MonoDomain * orig;

  if (domain == 0B) goto <D.28455>; else goto <D.28456>;
  <D.28455>:
  domain = mono_get_root_domain ();
  <D.28456>:
  mono_lmf_addr.54 = mono_lmf_addr;
  if (mono_lmf_addr.54 == 0B) goto <D.28458>; else goto <D.28459>;
  <D.28458>:
  mono_thread_attach (domain);
  D.28460 = mono_thread_internal_current ();
  mono_thread_set_state (D.28460, 4);
  <D.28459>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.28461>; else goto <D.28462>;
  <D.28461>:
  mono_domain_set (domain, 1);
  <D.28462>:
  if (orig != domain) goto <D.28465>; else goto <D.28466>;
  <D.28465>:
  iftmp.55 = orig;
  goto <D.28467>;
  <D.28466>:
  iftmp.55 = 0B;
  <D.28467>:
  D.28463 = iftmp.55;
  return D.28463;
}


mono_jit_set_domain (struct MonoDomain * domain)
{
  if (domain != 0B) goto <D.28469>; else goto <D.28470>;
  <D.28469>:
  mono_domain_set (domain, 1);
  <D.28470>:
}


__attribute__((visibility ("hidden")))
mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.28471;
  long int D.28472;
  long int D.28473;
  int D.28476;
  int offset;

  switch (key) <default: <D.25918>, case 0: <D.25912>, case 1: <D.25914>, case 2: <D.25915>, case 3: <D.25916>, case 8: <D.25917>>
  <D.25912>:
  offset = mono_thread_get_tls_offset ();
  goto <D.25913>;
  <D.25914>:
  offset = mono_get_jit_tls_offset ();
  goto <D.25913>;
  <D.25915>:
  offset = mono_domain_get_tls_offset ();
  goto <D.25913>;
  <D.25916>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.25913>;
  <D.25917>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.25913>;
  <D.25918>:
  offset = mono_tls_key_get_offset (key);
  D.28471 = offset == -1;
  D.28472 = (long int) D.28471;
  D.28473 = __builtin_expect (D.28472, 0);
  if (D.28473 != 0) goto <D.28474>; else goto <D.28475>;
  <D.28474>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.28475>:
  goto <D.25913>;
  <D.25913>:
  D.28476 = offset;
  return D.28476;
}


__attribute__((visibility ("hidden")))
mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  gboolean D.28480;
  long unsigned int D.28481;
  long unsigned int D.28482;
  int D.28485;
  _Bool D.28486;

  if (0 != 0) goto <D.28478>; else goto <D.28479>;
  <D.28478>:
  D.28480 = 0;
  return D.28480;
  <D.28479>:
  D.28481 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28482 = D.28481 & 33554432;
  if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
  <D.28483>:
  D.28480 = 0;
  return D.28480;
  <D.28484>:
  D.28485 = mini_get_tls_offset (key);
  D.28486 = D.28485 != -1;
  D.28480 = (gboolean) D.28486;
  return D.28480;
}


__attribute__((visibility ("hidden")))
mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  long unsigned int D.28488;
  long unsigned int D.28489;
  struct MonoMemPool * D.28496;
  long int D.28497;
  struct MonoInst * D.28498;
  guint16 iftmp.56;
  int D.28503;
  int D.28504;
  const unsigned char * D.28505;
  long int D.28506;
  void * D.28507;
  unsigned int D.28508;
  int D.28509;
  long int D.28511;
  void * D.28512;
  unsigned int D.28513;
  int D.28514;
  struct MonoBasicBlock * D.28515;
  struct MonoInst * D.28516;
  long int D.28520;
  struct MonoInst * D.28521;
  int D.28522;
  int D.28523;
  unsigned int D.28524;
  int D.28525;
  int D.28526;
  struct MonoInst * D.28527;
  int D.28528;

  D.28488 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28489 = D.28488 & 33554432;
  if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
  <D.28490>:
  if (0 != 0) goto <D.28492>; else goto <D.28493>;
  <D.28492>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.28488 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28489 = D.28488 & 33554432;
    if (D.28489 != 0) goto <D.28494>; else goto <D.28495>;
    <D.28494>:
    D.28496 = cfg->mempool;
    c = mono_mempool_alloc (D.28496, 80);
    c->data.op[1].const_val = 0;
    D.28497 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.28497;
    c->prev = 0B;
    D.28498 = c->prev;
    c->next = D.28498;
    D.28488 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28489 = D.28488 & 33554432;
    if (D.28489 != 0) goto <D.28500>; else goto <D.28501>;
    <D.28500>:
    iftmp.56 = 732;
    goto <D.28502>;
    <D.28501>:
    iftmp.56 = 363;
    <D.28502>:
    c->opcode = iftmp.56;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.28503 = c->sreg3;
    c->sreg2 = D.28503;
    D.28504 = c->sreg2;
    c->sreg1 = D.28504;
    D.28505 = cfg->ip;
    c->cil_code = D.28505;
    D.28506 = (long int) key;
    D.28507 = (void *) D.28506;
    c->data.op[0].p = D.28507;
    c->data.op[1].src = 48B;
    c->type = 3;
    D.28508 = alloc_dreg (cfg, 3);
    D.28509 = (int) D.28508;
    c->dreg = D.28509;
    goto <D.28510>;
    <D.28495>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.28496 = cfg->mempool;
      c = mono_mempool_alloc (D.28496, 80);
      c->data.op[1].const_val = 0;
      D.28497 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.28497;
      c->prev = 0B;
      D.28498 = c->prev;
      c->next = D.28498;
      c->opcode = 363;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.28503 = c->sreg3;
      c->sreg2 = D.28503;
      D.28504 = c->sreg2;
      c->sreg1 = D.28504;
      D.28505 = cfg->ip;
      c->cil_code = D.28505;
      D.28511 = (long int) _offset;
      D.28512 = (void *) D.28511;
      c->data.op[0].p = D.28512;
      c->type = 3;
      D.28513 = alloc_dreg (cfg, 3);
      D.28514 = (int) D.28513;
      c->dreg = D.28514;
    }
    <D.28510>:
    D.28515 = cfg->cbb;
    D.28516 = D.28515->last_ins;
    if (D.28516 != 0B) goto <D.28517>; else goto <D.28518>;
    <D.28517>:
    D.28515 = cfg->cbb;
    D.28516 = D.28515->last_ins;
    D.28516->next = c;
    D.28515 = cfg->cbb;
    D.28516 = D.28515->last_ins;
    c->prev = D.28516;
    D.28515 = cfg->cbb;
    D.28515->last_ins = c;
    goto <D.28519>;
    <D.28518>:
    D.28515 = cfg->cbb;
    D.28515 = cfg->cbb;
    D.28515->last_ins = c;
    D.28516 = D.28515->last_ins;
    D.28515->code = D.28516;
    <D.28519>:
    D.28496 = cfg->mempool;
    ins = mono_mempool_alloc (D.28496, 80);
    ins->data.op[1].const_val = 0;
    D.28520 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.28520;
    ins->prev = 0B;
    D.28521 = ins->prev;
    ins->next = D.28521;
    ins->opcode = 792;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.28522 = ins->sreg3;
    ins->sreg2 = D.28522;
    D.28523 = ins->sreg2;
    ins->sreg1 = D.28523;
    D.28505 = cfg->ip;
    ins->cil_code = D.28505;
    D.28524 = mono_alloc_preg (cfg);
    D.28525 = (int) D.28524;
    ins->dreg = D.28525;
    D.28526 = c->dreg;
    ins->sreg1 = D.28526;
    D.28527 = ins;
    return D.28527;
  }
  <D.28493>:
  D.28527 = 0B;
  return D.28527;
  <D.28491>:
  D.28528 = mini_get_tls_offset (key);
  D.28527 = mono_create_tls_get_offset (cfg, D.28528);
  return D.28527;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.28532;
  struct MonoMemPool * D.28535;
  long int D.28536;
  struct MonoInst * D.28537;
  int D.28538;
  int D.28539;
  const unsigned char * D.28540;
  unsigned int D.28541;
  int D.28542;
  long int D.28543;
  struct MonoInst * ins;

  if (0 != 0) goto <D.28530>; else goto <D.28531>;
  <D.28530>:
  D.28532 = 0B;
  return D.28532;
  <D.28531>:
  if (offset == -1) goto <D.28533>; else goto <D.28534>;
  <D.28533>:
  D.28532 = 0B;
  return D.28532;
  <D.28534>:
  D.28535 = cfg->mempool;
  ins = mono_mempool_alloc (D.28535, 80);
  ins->data.op[1].const_val = 0;
  D.28536 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.28536;
  ins->prev = 0B;
  D.28537 = ins->prev;
  ins->next = D.28537;
  ins->opcode = 791;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28538 = ins->sreg3;
  ins->sreg2 = D.28538;
  D.28539 = ins->sreg2;
  ins->sreg1 = D.28539;
  D.28540 = cfg->ip;
  ins->cil_code = D.28540;
  D.28541 = mono_alloc_preg (cfg);
  D.28542 = (int) D.28541;
  ins->dreg = D.28542;
  D.28543 = (long int) offset;
  ins->data.op[0].const_val = D.28543;
  D.28532 = ins;
  return D.28532;
}


__attribute__((visibility ("hidden")))
mono_get_jit_tls_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28545;

  D.28545 = mono_create_tls_get (cfg, 1);
  return D.28545;
}


__attribute__((visibility ("hidden")))
mono_get_domain_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28547;

  D.28547 = mono_create_tls_get (cfg, 2);
  return D.28547;
}


__attribute__((visibility ("hidden")))
mono_get_thread_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28549;

  D.28549 = mono_create_tls_get (cfg, 0);
  return D.28549;
}


__attribute__((visibility ("hidden")))
mono_get_lmf_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28551;

  D.28551 = mono_create_tls_get (cfg, 3);
  return D.28551;
}


__attribute__((visibility ("hidden")))
mono_get_lmf_addr_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28553;

  D.28553 = mono_create_tls_get (cfg, 8);
  return D.28553;
}


__attribute__((visibility ("hidden")))
mono_add_patch_info (struct MonoCompile * cfg, int ip, MonoJumpInfoType type, const void * target)
{
  struct MonoMemPool * D.28555;
  struct MonoJumpInfo * D.28556;
  struct MonoJumpInfo * ji;

  D.28555 = cfg->mempool;
  ji = mono_mempool_alloc0 (D.28555, 40);
  ji->ip.i = ip;
  ji->type = type;
  ji->data.target = target;
  D.28556 = cfg->patch_info;
  ji->next = D.28556;
  cfg->patch_info = ji;
}


__attribute__((visibility ("hidden")))
mono_add_patch_info_rel (struct MonoCompile * cfg, int ip, MonoJumpInfoType type, const void * target, int relocation)
{
  struct MonoMemPool * D.28557;
  struct MonoJumpInfo * D.28558;
  struct MonoJumpInfo * ji;

  D.28557 = cfg->mempool;
  ji = mono_mempool_alloc0 (D.28557, 40);
  ji->ip.i = ip;
  ji->type = type;
  ji->relocation = relocation;
  ji->data.target = target;
  D.28558 = cfg->patch_info;
  ji->next = D.28558;
  cfg->patch_info = ji;
}


__attribute__((visibility ("hidden")))
mono_patch_info_list_prepend (struct MonoJumpInfo * list, int ip, MonoJumpInfoType type, const void * target)
{
  struct MonoJumpInfo * D.28559;
  struct MonoJumpInfo * ji;

  ji = monoeg_malloc0 (40);
  ji->ip.i = ip;
  ji->type = type;
  ji->data.target = target;
  ji->next = list;
  D.28559 = ji;
  return D.28559;
}


__attribute__((visibility ("hidden")))
mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.28561;
  int D.28562;
  struct MonoJumpInfo * D.28565;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.25978>;
  <D.25977>:
  D.28561 = *ji;
  D.28562 = D.28561->ip.i;
  if (D.28562 == ip) goto <D.28563>; else goto <D.28564>;
  <D.28563>:
  D.28561 = *ji;
  D.28565 = D.28561->next;
  *ji = D.28565;
  goto <D.28566>;
  <D.28564>:
  D.28561 = *ji;
  ji = &D.28561->next;
  <D.28566>:
  <D.25978>:
  D.28561 = *ji;
  if (D.28561 != 0B) goto <D.25977>; else goto <D.25979>;
  <D.25979>:
}


__attribute__((visibility ("hidden")))
mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.28567;
  void * D.28568;
  struct MonoJumpInfoToken * D.28569;
  struct MonoJumpInfoToken * D.28570;
  void * D.28571;
  struct MonoJumpInfoBBTable * D.28572;
  struct MonoJumpInfoBBTable * D.28573;
  int D.28574;
  long unsigned int D.28575;
  unsigned int D.28576;
  unsigned int D.28577;
  void * D.28578;
  struct MonoBasicBlock * * D.28579;
  struct MonoBasicBlock * * D.28580;
  long unsigned int D.28581;
  void * D.28582;
  struct MonoJumpInfoRgctxEntry * D.28583;
  struct MonoJumpInfoRgctxEntry * D.28584;
  struct MonoJumpInfo * D.28585;
  struct MonoJumpInfo * D.28586;
  void * D.28587;
  struct MonoJumpInfoGSharedVtCall * D.28588;
  struct MonoJumpInfoGSharedVtCall * D.28589;
  struct GPtrArray * D.28590;
  struct GPtrArray * D.28591;
  void * * D.28594;
  long unsigned int D.28595;
  long unsigned int D.28596;
  void * * D.28597;
  struct GPtrArray * D.28598;
  unsigned int D.28599;
  unsigned int i.57;
  struct MonoJumpInfo * D.28601;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 40);
  memcpy (res, patch_info, 40);
  D.28567 = patch_info->type;
  switch (D.28567) <default: <D.26003>, case 8: <D.25991>, case 17: <D.25986>, case 18: <D.25988>, case 19: <D.25987>, case 28: <D.25989>, case 29: <D.25985>, case 35: <D.25992>, case 45: <D.25993>, case 46: <D.25994>>
  <D.25985>:
  <D.25986>:
  <D.25987>:
  <D.25988>:
  <D.25989>:
  D.28568 = mono_mempool_alloc (mp, 32);
  res->data.token = D.28568;
  D.28569 = res->data.token;
  D.28570 = patch_info->data.token;
  memcpy (D.28569, D.28570, 32);
  goto <D.25990>;
  <D.25991>:
  D.28571 = mono_mempool_alloc (mp, 16);
  res->data.table = D.28571;
  D.28572 = res->data.table;
  D.28573 = patch_info->data.table;
  memcpy (D.28572, D.28573, 16);
  D.28572 = res->data.table;
  D.28573 = patch_info->data.table;
  D.28574 = D.28573->table_size;
  D.28575 = (long unsigned int) D.28574;
  D.28576 = (unsigned int) D.28575;
  D.28577 = D.28576 * 8;
  D.28578 = mono_mempool_alloc (mp, D.28577);
  D.28572->table = D.28578;
  D.28572 = res->data.table;
  D.28579 = D.28572->table;
  D.28573 = patch_info->data.table;
  D.28580 = D.28573->table;
  D.28573 = patch_info->data.table;
  D.28574 = D.28573->table_size;
  D.28575 = (long unsigned int) D.28574;
  D.28581 = D.28575 * 8;
  memcpy (D.28579, D.28580, D.28581);
  goto <D.25990>;
  <D.25992>:
  D.28582 = mono_mempool_alloc (mp, 32);
  res->data.rgctx_entry = D.28582;
  D.28583 = res->data.rgctx_entry;
  D.28584 = patch_info->data.rgctx_entry;
  memcpy (D.28583, D.28584, 32);
  D.28583 = res->data.rgctx_entry;
  D.28583 = res->data.rgctx_entry;
  D.28585 = D.28583->data;
  D.28586 = mono_patch_info_dup_mp (mp, D.28585);
  D.28583->data = D.28586;
  goto <D.25990>;
  <D.25993>:
  D.28587 = mono_mempool_alloc (mp, 16);
  res->data.gsharedvt = D.28587;
  D.28588 = res->data.gsharedvt;
  D.28589 = patch_info->data.gsharedvt;
  memcpy (D.28588, D.28589, 16);
  goto <D.25990>;
  <D.25994>:
  {
    struct MonoGSharedVtMethodInfo * info;
    struct MonoGSharedVtMethodInfo * oinfo;
    int i;

    oinfo = patch_info->data.gsharedvt_method;
    info = mono_mempool_alloc (mp, 16);
    res->data.gsharedvt_method = info;
    memcpy (info, oinfo, 16);
    D.28590 = monoeg_g_ptr_array_new ();
    info->entries = D.28590;
    D.28591 = oinfo->entries;
    if (D.28591 != 0B) goto <D.28592>; else goto <D.28593>;
    <D.28592>:
    i = 0;
    goto <D.26001>;
    <D.26000>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.28591 = oinfo->entries;
      D.28594 = D.28591->pdata;
      D.28595 = (long unsigned int) i;
      D.28596 = D.28595 * 8;
      D.28597 = D.28594 + D.28596;
      otemplate = *D.28597;
      template = mono_mempool_alloc0 (mp, 24);
      memcpy (template, otemplate, 24);
      D.28598 = info->entries;
      monoeg_g_ptr_array_add (D.28598, template);
    }
    i = i + 1;
    <D.26001>:
    D.28591 = oinfo->entries;
    D.28599 = D.28591->len;
    i.57 = (unsigned int) i;
    if (D.28599 > i.57) goto <D.26000>; else goto <D.26002>;
    <D.26002>:
    <D.28593>:
    goto <D.25990>;
  }
  <D.26003>:
  goto <D.25990>;
  <D.25990>:
  D.28601 = res;
  return D.28601;
}


__attribute__((visibility ("hidden")))
mono_patch_info_hash (const void * data)
{
  <unnamed type> D.28604;
  guint D.28605;
  unsigned int D.28606;
  struct MonoJumpInfoToken * D.28607;
  unsigned int D.28608;
  unsigned int D.28609;
  guint iftmp.58;
  int D.28611;
  struct MonoGenericInst * D.28614;
  long int D.28615;
  const char * D.28617;
  unsigned int D.28618;
  signed int D.28619;
  const void * D.28620;
  long int D.28621;
  signed int D.28622;
  signed int D.28623;
  struct MonoJumpInfoGSharedVtCall * D.28624;
  struct MonoMethod * D.28625;
  long int D.28626;
  signed int D.28627;
  signed int D.28628;
  struct MonoMethod * D.28629;
  long int D.28630;
  signed int D.28631;
  signed int D.28632;
  int D.28633;
  signed int D.28634;
  <unnamed type> D.28635;
  signed int D.28636;
  signed int D.28637;
  struct MonoJumpInfo * D.28638;
  unsigned int D.28639;
  signed int D.28640;
  signed int D.28641;
  struct MonoJumpInfoBBTable * D.28642;
  int D.28643;
  unsigned int D.28644;
  struct MonoGSharedVtMethodInfo * D.28645;
  struct MonoMethod * D.28646;
  long int D.28647;
  signed int D.28648;
  signed int D.28649;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.28604 = ji->type;
  switch (D.28604) <default: <D.26048>, case 3: <D.26021>, case 4: <D.26022>, case 6: <D.26020>, case 7: <D.26013>, case 8: <D.26045>, case 11: <D.26015>, case 12: <D.26023>, case 13: <D.26026>, case 14: <D.26014>, case 15: <D.26018>, case 16: <D.26027>, case 17: <D.26009>, case 18: <D.26010>, case 19: <D.26012>, case 23: <D.26016>, case 24: <D.26017>, case 27: <D.26044>, case 28: <D.26011>, case 29: <D.26008>, case 30: <D.26030>, case 31: <D.26025>, case 32: <D.26024>, case 33: <D.26037>, case 34: <D.26029>, case 35: <D.26035>, case 36: <D.26019>, case 37: <D.26041>, case 38: <D.26042>, case 39: <D.26038>, case 40: <D.26028>, case 42: <D.26039>, case 43: <D.26043>, case 44: <D.26031>, case 45: <D.26034>, case 46: <D.26046>, case 47: <D.26040>, case 48: <D.26032>, case 49: <D.26047>, case 50: <D.26033>>
  <D.26008>:
  <D.26009>:
  <D.26010>:
  <D.26011>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28607 = ji->data.token;
  D.28608 = D.28607->token;
  D.28605 = D.28606 | D.28608;
  return D.28605;
  <D.26012>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28607 = ji->data.token;
  D.28608 = D.28607->token;
  D.28609 = D.28606 | D.28608;
  D.28607 = ji->data.token;
  D.28611 = D.28607->has_context;
  if (D.28611 != 0) goto <D.28612>; else goto <D.28613>;
  <D.28612>:
  D.28607 = ji->data.token;
  D.28614 = D.28607->context.class_inst;
  D.28615 = (long int) D.28614;
  iftmp.58 = (guint) D.28615;
  goto <D.28616>;
  <D.28613>:
  iftmp.58 = 0;
  <D.28616>:
  D.28605 = D.28609 | iftmp.58;
  return D.28605;
  <D.26013>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28617 = ji->data.name;
  D.28618 = monoeg_g_str_hash (D.28617);
  D.28605 = D.28606 | D.28618;
  return D.28605;
  <D.26014>:
  <D.26015>:
  <D.26016>:
  <D.26017>:
  <D.26018>:
  <D.26019>:
  <D.26020>:
  <D.26021>:
  <D.26022>:
  <D.26023>:
  <D.26024>:
  <D.26025>:
  <D.26026>:
  <D.26027>:
  <D.26028>:
  <D.26029>:
  <D.26030>:
  <D.26031>:
  <D.26032>:
  <D.26033>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28619 = (signed int) D.28606;
  D.28620 = ji->data.target;
  D.28621 = (long int) D.28620;
  D.28622 = (signed int) D.28621;
  D.28623 = D.28619 | D.28622;
  D.28605 = (guint) D.28623;
  return D.28605;
  <D.26034>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28619 = (signed int) D.28606;
  D.28624 = ji->data.gsharedvt;
  D.28625 = D.28624->method;
  D.28626 = (long int) D.28625;
  D.28627 = (signed int) D.28626;
  D.28628 = D.28619 | D.28627;
  D.28605 = (guint) D.28628;
  return D.28605;
  <D.26035>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.28604 = ji->type;
    D.28606 = D.28604 << 8;
    D.28619 = (signed int) D.28606;
    D.28629 = e->method;
    D.28630 = (long int) D.28629;
    D.28631 = (signed int) D.28630;
    D.28632 = D.28619 | D.28631;
    D.28633 = e->in_mrgctx;
    D.28634 = D.28632 | D.28633;
    D.28635 = e->info_type;
    D.28636 = (signed int) D.28635;
    D.28637 = D.28634 | D.28636;
    D.28638 = e->data;
    D.28639 = mono_patch_info_hash (D.28638);
    D.28640 = (signed int) D.28639;
    D.28641 = D.28637 | D.28640;
    D.28605 = (guint) D.28641;
    return D.28605;
  }
  <D.26037>:
  <D.26038>:
  <D.26039>:
  <D.26040>:
  <D.26041>:
  <D.26042>:
  <D.26043>:
  <D.26044>:
  D.28604 = ji->type;
  D.28605 = D.28604 << 8;
  return D.28605;
  <D.26045>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28642 = ji->data.table;
  D.28643 = D.28642->table_size;
  D.28644 = (unsigned int) D.28643;
  D.28605 = D.28606 | D.28644;
  return D.28605;
  <D.26046>:
  D.28604 = ji->type;
  D.28606 = D.28604 << 8;
  D.28619 = (signed int) D.28606;
  D.28645 = ji->data.gsharedvt_method;
  D.28646 = D.28645->method;
  D.28647 = (long int) D.28646;
  D.28648 = (signed int) D.28647;
  D.28649 = D.28619 | D.28648;
  D.28605 = (guint) D.28649;
  return D.28605;
  <D.26047>:
  D.28620 = ji->data.target;
  D.28605 = monoeg_g_str_hash (D.28620);
  return D.28605;
  <D.26048>:
  D.28604 = ji->type;
  printf ("info type: %d\n", D.28604);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.28605 = 0;
  return D.28605;
}


__attribute__((visibility ("hidden")))
mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.28651;
  <unnamed type> D.28652;
  gint D.28655;
  struct MonoJumpInfoToken * D.28658;
  struct MonoImage * D.28659;
  struct MonoJumpInfoToken * D.28660;
  struct MonoImage * D.28661;
  long unsigned int D.28663;
  long unsigned int D.28664;
  long unsigned int D.28665;
  long unsigned int D.28666;
  struct MonoGenericInst * D.28668;
  struct MonoGenericInst * D.28669;
  struct MonoGenericInst * D.28671;
  struct MonoGenericInst * D.28672;
  const char * D.28673;
  const char * D.28674;
  int iftmp.59;
  struct MonoMethod * D.28678;
  struct MonoMethod * D.28679;
  int D.28681;
  int D.28682;
  <unnamed type> D.28684;
  <unnamed type> D.28685;
  struct MonoJumpInfo * D.28687;
  struct MonoJumpInfo * D.28688;
  int D.28689;
  int iftmp.60;
  struct MonoMethodSignature * D.28694;
  struct MonoMethodSignature * D.28695;
  struct MonoMethod * D.28697;
  struct MonoMethod * D.28698;
  struct MonoGSharedVtMethodInfo * D.28700;
  struct MonoMethod * D.28701;
  struct MonoGSharedVtMethodInfo * D.28702;
  struct MonoMethod * D.28703;
  _Bool D.28704;
  const void * D.28705;
  const void * D.28706;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.28651 = ji1->type;
  D.28652 = ji2->type;
  if (D.28651 != D.28652) goto <D.28653>; else goto <D.28654>;
  <D.28653>:
  D.28655 = 0;
  return D.28655;
  <D.28654>:
  D.28651 = ji1->type;
  switch (D.28651) <default: <D.26069>, case 7: <D.26061>, case 17: <D.26056>, case 18: <D.26058>, case 19: <D.26057>, case 28: <D.26059>, case 29: <D.26055>, case 35: <D.26062>, case 45: <D.26065>, case 46: <D.26068>>
  <D.26055>:
  <D.26056>:
  <D.26057>:
  <D.26058>:
  <D.26059>:
  D.28658 = ji1->data.token;
  D.28659 = D.28658->image;
  D.28660 = ji2->data.token;
  D.28661 = D.28660->image;
  if (D.28659 != D.28661) goto <D.28656>; else goto <D.28662>;
  <D.28662>:
  D.28658 = ji1->data.token;
  D.28663 = BIT_FIELD_REF <*D.28658, 64, 64>;
  D.28664 = D.28663;
  D.28660 = ji2->data.token;
  D.28665 = BIT_FIELD_REF <*D.28660, 64, 64>;
  D.28666 = D.28665;
  if (D.28664 != D.28666) goto <D.28656>; else goto <D.28667>;
  <D.28667>:
  D.28658 = ji1->data.token;
  D.28668 = D.28658->context.class_inst;
  D.28660 = ji2->data.token;
  D.28669 = D.28660->context.class_inst;
  if (D.28668 != D.28669) goto <D.28656>; else goto <D.28670>;
  <D.28670>:
  D.28658 = ji1->data.token;
  D.28671 = D.28658->context.method_inst;
  D.28660 = ji2->data.token;
  D.28672 = D.28660->context.method_inst;
  if (D.28671 != D.28672) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  D.28655 = 0;
  return D.28655;
  <D.28657>:
  goto <D.26060>;
  <D.26061>:
  D.28673 = ji1->data.name;
  D.28674 = ji2->data.name;
  D.28655 = monoeg_g_str_equal (D.28673, D.28674);
  return D.28655;
  <D.26062>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.28678 = e1->method;
    D.28679 = e2->method;
    if (D.28678 == D.28679) goto <D.28680>; else goto <D.28676>;
    <D.28680>:
    D.28681 = e1->in_mrgctx;
    D.28682 = e2->in_mrgctx;
    if (D.28681 == D.28682) goto <D.28683>; else goto <D.28676>;
    <D.28683>:
    D.28684 = e1->info_type;
    D.28685 = e2->info_type;
    if (D.28684 == D.28685) goto <D.28686>; else goto <D.28676>;
    <D.28686>:
    D.28687 = e1->data;
    D.28688 = e2->data;
    D.28689 = mono_patch_info_equal (D.28687, D.28688);
    if (D.28689 != 0) goto <D.28690>; else goto <D.28676>;
    <D.28690>:
    iftmp.59 = 1;
    goto <D.28677>;
    <D.28676>:
    iftmp.59 = 0;
    <D.28677>:
    D.28655 = iftmp.59;
    return D.28655;
  }
  <D.26065>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.28694 = c1->sig;
    D.28695 = c2->sig;
    if (D.28694 == D.28695) goto <D.28696>; else goto <D.28692>;
    <D.28696>:
    D.28697 = c1->method;
    D.28698 = c2->method;
    if (D.28697 == D.28698) goto <D.28699>; else goto <D.28692>;
    <D.28699>:
    iftmp.60 = 1;
    goto <D.28693>;
    <D.28692>:
    iftmp.60 = 0;
    <D.28693>:
    D.28655 = iftmp.60;
    return D.28655;
  }
  <D.26068>:
  D.28700 = ji1->data.gsharedvt_method;
  D.28701 = D.28700->method;
  D.28702 = ji2->data.gsharedvt_method;
  D.28703 = D.28702->method;
  D.28704 = D.28701 == D.28703;
  D.28655 = (gint) D.28704;
  return D.28655;
  <D.26069>:
  D.28705 = ji1->data.target;
  D.28706 = ji2->data.target;
  if (D.28705 != D.28706) goto <D.28707>; else goto <D.28708>;
  <D.28707>:
  D.28655 = 0;
  return D.28655;
  <D.28708>:
  goto <D.26060>;
  <D.26060>:
  D.28655 = 1;
  return D.28655;
}


__attribute__((visibility ("hidden")))
mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.28710;
  sizetype D.28711;
  <unnamed type> D.28712;
  struct MonoBasicBlock * D.28713;
  int D.28714;
  sizetype D.28715;
  struct MonoInst * D.28716;
  long int D.28717;
  sizetype D.28718;
  long int D.28719;
  sizetype D.28720;
  const char * D.28721;
  struct MonoMethod * D.28726;
  union mono_mutex_t * D.28730;
  _Bool D.28733;
  long int D.28734;
  long int D.28735;
  void * D.28738;
  struct GHashTable * D.28739;
  struct GHashTable * D.28742;
  _Bool D.28747;
  long int D.28748;
  long int D.28749;
  long unsigned int D.28755;
  long unsigned int D.28756;
  struct MonoJitDynamicMethodInfo * D.28758;
  struct MonoCodeManager * D.28759;
  struct MonoJumpInfoBBTable * D.28760;
  int D.28761;
  unsigned int D.28762;
  unsigned int D.28763;
  int D.28764;
  int mono_aot_only.61;
  long unsigned int D.28768;
  unsigned int D.28769;
  unsigned int D.28770;
  long unsigned int D.28772;
  long unsigned int D.28773;
  void * * D.28774;
  struct MonoBasicBlock * * D.28775;
  struct MonoBasicBlock * * D.28776;
  struct MonoBasicBlock * D.28777;
  long int D.28778;
  int D.28779;
  sizetype D.28780;
  guint8 * D.28781;
  struct MonoClass * D.28782;
  short unsigned int D.28783;
  long int D.28784;
  int D.28785;
  int D.28786;
  int D.28787;
  long int D.28788;
  _Bool D.28789;
  long int D.28790;
  long int D.28791;
  _Bool D.28794;
  long int D.28795;
  long int D.28796;
  struct MonoClassField * D.28799;
  struct MonoClass * D.28800;
  int D.28801;
  _Bool D.28806;
  long int D.28807;
  long int D.28808;
  struct GHashTable * D.28811;
  _Bool D.28816;
  long int D.28817;
  long int D.28818;
  _Bool D.28821;
  long int D.28822;
  long int D.28823;
  void * D.28826;
  _Bool D.28827;
  long int D.28828;
  long int D.28829;
  long unsigned int D.28834;
  long unsigned int D.28835;
  struct MonoClass * D.28837;
  unsigned int D.28838;
  unsigned int D.28839;
  int D.28842;
  void * D.28846;
  int D.28847;
  sizetype D.28848;
  struct MonoJumpInfoToken * D.28849;
  unsigned int D.28850;
  struct MonoImage * D.28851;
  unsigned int D.28852;
  unsigned int rva.62;
  unsigned int D.28854;
  struct MonoGenericContext * iftmp.63;
  int D.28856;
  struct MonoClass * handle_class.64;
  struct MonoClass * D.28861;
  struct MonoGenericContext * iftmp.65;
  struct MonoClass * handle_class.66;
  const char * D.28867;
  short unsigned int D.28868;
  int D.28869;
  int D.28870;
  struct MonoImage * D.28879;
  const char * exc_class.67;
  const char * exc_arg.68;
  struct MonoException * D.28882;
  char * D.28883;
  char * D.28890;
  struct MonoClass * D.28891;
  _Bool D.28892;
  long int D.28893;
  long int D.28894;
  struct MonoGenericContext * D.28897;
  struct MonoGenericInst * D.28898;
  struct MonoJumpInfo * D.28899;
  <unnamed type> D.28900;
  struct MonoMethod * D.28901;
  int D.28902;
  struct MonoClass * D.28903;
  struct MonoType * D.28904;
  <unnamed type> D.28905;
  struct MonoGenericContext * D.28906;
  struct MonoMethod * D.28907;
  struct MonoGenericContext * D.28908;
  struct MonoClassField * D.28909;
  struct MonoGenericContext * D.28910;
  struct MonoMethodSignature * D.28911;
  struct MonoGenericContext * D.28912;
  struct MonoJumpInfoGSharedVtCall * D.28913;
  struct MonoGenericContext * D.28914;
  struct MonoMethod * D.28915;
  struct GPtrArray * D.28916;
  struct GPtrArray * D.28917;
  void * * D.28918;
  long unsigned int D.28919;
  long unsigned int D.28920;
  void * * D.28921;
  struct GPtrArray * D.28922;
  unsigned int D.28923;
  unsigned int i.69;
  struct MonoGenericContext * D.28925;
  unsigned int mono_jit_tls_id.70;
  long unsigned int D.28930;
  const void * D.28931;
  long int D.28932;
  <unnamed type> D.28933;
  long int D.28934;
  unsigned char * ip;
  const void * target;

  D.28710 = patch_info->ip.i;
  D.28711 = (sizetype) D.28710;
  ip = code + D.28711;
  target = 0B;
  D.28712 = patch_info->type;
  switch (D.28712) <default: <D.26177>, case 0: <D.26079>, case 1: <D.26081>, case 2: <D.26082>, case 3: <D.26090>, case 4: <D.26089>, case 5: <D.26084>, case 6: <D.26101>, case 7: <D.26085>, case 8: <D.26095>, case 10: <D.26122>, case 11: <D.26102>, case 12: <D.26103>, case 13: <D.26104>, case 14: <D.26108>, case 15: <D.26109>, case 16: <D.26112>, case 17: <D.26123>, case 18: <D.26127>, case 19: <D.26124>, case 20: <D.26120>, case 21: <D.26121>, case 22: <D.26083>, case 23: <D.26106>, case 24: <D.26107>, case 25: <D.26139>, case 26: <D.26140>, case 27: <D.26141>, case 28: <D.26130>, case 29: <D.26117>, case 30: <D.26111>, case 31: <D.26131>, case 32: <D.26087>, case 33: <D.26136>, case 34: <D.26137>, case 35: <D.26143>, case 36: <D.26164>, case 37: <D.26165>, case 38: <D.26166>, case 40: <D.26167>, case 41: <D.26168>, case 42: <D.26169>, case 43: <D.26172>, case 44: <D.26105>, case 47: <D.26173>, case 48: <D.26174>, case 49: <D.26176>, case 50: <D.26091>, case 51: <D.26142>>
  <D.26079>:
  D.28713 = patch_info->data.bb;
  D.28714 = D.28713->native_offset;
  D.28715 = (sizetype) D.28714;
  target = code + D.28715;
  goto <D.26080>;
  <D.26081>:
  target = patch_info->data.target;
  goto <D.26080>;
  <D.26082>:
  D.28716 = patch_info->data.inst;
  D.28717 = D.28716->data.op[0].const_val;
  D.28718 = (sizetype) D.28717;
  target = code + D.28718;
  goto <D.26080>;
  <D.26083>:
  target = ip;
  goto <D.26080>;
  <D.26084>:
  D.28719 = patch_info->data.offset;
  D.28720 = (sizetype) D.28719;
  target = code + D.28720;
  goto <D.26080>;
  <D.26085>:
  {
    struct MonoJitICallInfo * mi;

    D.28721 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.28721);
    if (mi == 0B) goto <D.28722>; else goto <D.28723>;
    <D.28722>:
    D.28721 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_INTERNAL_METHOD %s", D.28721);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3299);
    <D.28723>:
    target = mono_icall_get_wrapper (mi);
    goto <D.26080>;
  }
  <D.26087>:
  {
    struct MonoJitICallInfo * mi;

    D.28721 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.28721);
    if (mi == 0B) goto <D.28724>; else goto <D.28725>;
    <D.28724>:
    D.28721 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.28721);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.28725>:
    target = mi->func;
    goto <D.26080>;
  }
  <D.26089>:
  D.28726 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.28726, 0);
  goto <D.26080>;
  <D.26090>:
  D.28726 = patch_info->data.method;
  if (D.28726 == method) goto <D.28727>; else goto <D.28728>;
  <D.28727>:
  target = code;
  goto <D.28729>;
  <D.28728>:
  D.28726 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.28726);
  <D.28729>:
  goto <D.26080>;
  <D.26091>:
  {
    void * code_slot;

    {
      int ret;

      D.28730 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28730);
      if (ret != 0) goto <D.28731>; else goto <D.28732>;
      <D.28731>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28732>:
      D.28733 = ret != 0;
      D.28734 = (long int) D.28733;
      D.28735 = __builtin_expect (D.28734, 0);
      if (D.28735 != 0) goto <D.28736>; else goto <D.28737>;
      <D.28736>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.28737>:
    }
    D.28738 = domain->runtime_info;
    D.28739 = MEM[(struct MonoJitDomainInfo *)D.28738].method_code_hash;
    if (D.28739 == 0B) goto <D.28740>; else goto <D.28741>;
    <D.28740>:
    D.28738 = domain->runtime_info;
    D.28742 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.28738].method_code_hash = D.28742;
    <D.28741>:
    D.28738 = domain->runtime_info;
    D.28739 = MEM[(struct MonoJitDomainInfo *)D.28738].method_code_hash;
    D.28726 = patch_info->data.method;
    code_slot = monoeg_g_hash_table_lookup (D.28739, D.28726);
    if (code_slot == 0B) goto <D.28743>; else goto <D.28744>;
    <D.28743>:
    code_slot = mono_domain_alloc0 (domain, 8);
    D.28738 = domain->runtime_info;
    D.28739 = MEM[(struct MonoJitDomainInfo *)D.28738].method_code_hash;
    D.28726 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.28739, D.28726, code_slot, 0);
    <D.28744>:
    {
      int ret;

      D.28730 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28730);
      if (ret != 0) goto <D.28745>; else goto <D.28746>;
      <D.28745>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28746>:
      D.28747 = ret != 0;
      D.28748 = (long int) D.28747;
      D.28749 = __builtin_expect (D.28748, 0);
      if (D.28749 != 0) goto <D.28750>; else goto <D.28751>;
      <D.28750>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.28751>:
    }
    target = code_slot;
    goto <D.26080>;
  }
  <D.26095>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.28754>; else goto <D.28752>;
    <D.28754>:
    D.28755 = BIT_FIELD_REF <*method, 64, 256>;
    D.28756 = D.28755 & 18014398509481984;
    if (D.28756 != 0) goto <D.28757>; else goto <D.28752>;
    <D.28757>:
    D.28758 = mono_dynamic_code_hash_lookup (domain, method);
    D.28759 = D.28758->code_mp;
    D.28760 = patch_info->data.table;
    D.28761 = D.28760->table_size;
    D.28762 = (unsigned int) D.28761;
    D.28763 = D.28762 * 8;
    D.28764 = (int) D.28763;
    jump_table = mono_code_manager_reserve (D.28759, D.28764);
    goto <D.28753>;
    <D.28752>:
    mono_aot_only.61 = mono_aot_only;
    if (mono_aot_only.61 != 0) goto <D.28766>; else goto <D.28767>;
    <D.28766>:
    D.28760 = patch_info->data.table;
    D.28761 = D.28760->table_size;
    D.28768 = (long unsigned int) D.28761;
    D.28769 = (unsigned int) D.28768;
    D.28770 = D.28769 * 8;
    jump_table = mono_domain_alloc (domain, D.28770);
    goto <D.28771>;
    <D.28767>:
    D.28760 = patch_info->data.table;
    D.28761 = D.28760->table_size;
    D.28762 = (unsigned int) D.28761;
    D.28763 = D.28762 * 8;
    D.28764 = (int) D.28763;
    jump_table = mono_domain_code_reserve (domain, D.28764);
    <D.28771>:
    <D.28753>:
    i = 0;
    goto <D.26099>;
    <D.26098>:
    D.28772 = (long unsigned int) i;
    D.28773 = D.28772 * 8;
    D.28774 = jump_table + D.28773;
    D.28760 = patch_info->data.table;
    D.28775 = D.28760->table;
    D.28772 = (long unsigned int) i;
    D.28773 = D.28772 * 8;
    D.28776 = D.28775 + D.28773;
    D.28777 = *D.28776;
    D.28778 = (long int) D.28777;
    D.28779 = (int) D.28778;
    D.28780 = (sizetype) D.28779;
    D.28781 = code + D.28780;
    *D.28774 = D.28781;
    i = i + 1;
    <D.26099>:
    D.28760 = patch_info->data.table;
    D.28761 = D.28760->table_size;
    if (D.28761 > i) goto <D.26098>; else goto <D.26100>;
    <D.26100>:
    target = jump_table;
    goto <D.26080>;
  }
  <D.26101>:
  <D.26102>:
  <D.26103>:
  <D.26104>:
  <D.26105>:
  target = patch_info->data.target;
  goto <D.26080>;
  <D.26106>:
  D.28782 = patch_info->data.klass;
  mono_class_init (D.28782);
  D.28782 = patch_info->data.klass;
  D.28783 = D.28782->interface_id;
  D.28784 = (long int) D.28783;
  target = (const void *) D.28784;
  goto <D.26080>;
  <D.26107>:
  D.28782 = patch_info->data.klass;
  mono_class_init (D.28782);
  D.28782 = patch_info->data.klass;
  D.28783 = D.28782->interface_id;
  D.28785 = (int) D.28783;
  D.28786 = D.28785 + 1;
  D.28787 = D.28786 * -8;
  D.28788 = (long int) D.28787;
  target = (const void *) D.28788;
  goto <D.26080>;
  <D.26108>:
  D.28782 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.28782);
  D.28789 = target == 0B;
  D.28790 = (long int) D.28789;
  D.28791 = __builtin_expect (D.28790, 0);
  if (D.28791 != 0) goto <D.28792>; else goto <D.28793>;
  <D.28792>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.28793>:
  goto <D.26080>;
  <D.26109>:
  {
    struct MonoVTable * vtable;

    D.28782 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.28782);
    D.28794 = vtable == 0B;
    D.28795 = (long int) D.28794;
    D.28796 = __builtin_expect (D.28795, 0);
    if (D.28796 != 0) goto <D.28797>; else goto <D.28798>;
    <D.28797>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.28798>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.26080>;
  }
  <D.26111>:
  D.28782 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.28782);
  goto <D.26080>;
  <D.26112>:
  {
    struct MonoVTable * vtable;

    D.28799 = patch_info->data.field;
    D.28800 = D.28799->parent;
    vtable = mono_class_vtable (domain, D.28800);
    D.28799 = patch_info->data.field;
    D.28801 = mono_class_field_is_special_static (D.28799);
    if (D.28801 != 0) goto <D.28802>; else goto <D.28803>;
    <D.28802>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.28730 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.28730);
        if (ret != 0) goto <D.28804>; else goto <D.28805>;
        <D.28804>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28805>:
        D.28806 = ret != 0;
        D.28807 = (long int) D.28806;
        D.28808 = __builtin_expect (D.28807, 0);
        if (D.28808 != 0) goto <D.28809>; else goto <D.28810>;
        <D.28809>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.28810>:
      }
      D.28811 = domain->special_static_fields;
      if (D.28811 != 0B) goto <D.28812>; else goto <D.28813>;
      <D.28812>:
      D.28811 = domain->special_static_fields;
      D.28799 = patch_info->data.field;
      addr = monoeg_g_hash_table_lookup (D.28811, D.28799);
      <D.28813>:
      {
        int ret;

        D.28730 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.28730);
        if (ret != 0) goto <D.28814>; else goto <D.28815>;
        <D.28814>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28815>:
        D.28816 = ret != 0;
        D.28817 = (long int) D.28816;
        D.28818 = __builtin_expect (D.28817, 0);
        if (D.28818 != 0) goto <D.28819>; else goto <D.28820>;
        <D.28819>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.28820>:
      }
      D.28821 = addr == 0B;
      D.28822 = (long int) D.28821;
      D.28823 = __builtin_expect (D.28822, 0);
      if (D.28823 != 0) goto <D.28824>; else goto <D.28825>;
      <D.28824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.28825>:
      D.28826 = addr;
      return D.28826;
    }
    <D.28803>:
    D.28827 = vtable == 0B;
    D.28828 = (long int) D.28827;
    D.28829 = __builtin_expect (D.28828, 0);
    if (D.28829 != 0) goto <D.28830>; else goto <D.28831>;
    <D.28830>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.28831>:
    D.28834 = BIT_FIELD_REF <*vtable, 64, 320>;
    D.28835 = D.28834 & 274877906944;
    if (D.28835 == 0) goto <D.28836>; else goto <D.28832>;
    <D.28836>:
    D.28837 = vtable->klass;
    D.28838 = D.28837->flags;
    D.28839 = D.28838 & 1048576;
    if (D.28839 == 0) goto <D.28840>; else goto <D.28832>;
    <D.28840>:
    if (method != 0B) goto <D.28841>; else goto <D.28832>;
    <D.28841>:
    D.28837 = vtable->klass;
    D.28842 = mono_class_needs_cctor_run (D.28837, method);
    if (D.28842 != 0) goto <D.28843>; else goto <D.28832>;
    <D.28843>:
    goto <D.28833>;
    <D.28832>:
    if (run_cctors != 0) goto <D.28844>; else goto <D.28845>;
    <D.28844>:
    mono_runtime_class_init (vtable);
    <D.28845>:
    <D.28833>:
    D.28846 = mono_vtable_get_static_field_data (vtable);
    D.28799 = patch_info->data.field;
    D.28847 = D.28799->offset;
    D.28848 = (sizetype) D.28847;
    target = D.28846 + D.28848;
    goto <D.26080>;
  }
  <D.26117>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.28849 = patch_info->data.token;
        D.28850 = D.28849->token;
        field_index = D.28850 & 16777215;
        D.28849 = patch_info->data.token;
        D.28851 = D.28849->image;
        D.28852 = field_index + 4294967295;
        mono_metadata_field_info (D.28851, D.28852, 0B, &rva, 0B);
        D.28849 = patch_info->data.token;
        D.28851 = D.28849->image;
        rva.62 = rva;
        target = mono_image_rva_map (D.28851, rva.62);
        goto <D.26080>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.26120>:
  <D.26121>:
  target = patch_info->data.target;
  goto <D.26080>;
  <D.26122>:
  target = patch_info->data.name;
  goto <D.26080>;
  <D.26123>:
  D.28849 = patch_info->data.token;
  D.28851 = D.28849->image;
  D.28849 = patch_info->data.token;
  D.28850 = D.28849->token;
  D.28854 = D.28850 & 16777215;
  target = mono_ldstr (domain, D.28851, D.28854);
  goto <D.26080>;
  <D.26124>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28849 = patch_info->data.token;
        D.28851 = D.28849->image;
        D.28849 = patch_info->data.token;
        D.28850 = D.28849->token;
        D.28849 = patch_info->data.token;
        D.28856 = D.28849->has_context;
        if (D.28856 != 0) goto <D.28857>; else goto <D.28858>;
        <D.28857>:
        D.28849 = patch_info->data.token;
        iftmp.63 = &D.28849->context;
        goto <D.28859>;
        <D.28858>:
        iftmp.63 = 0B;
        <D.28859>:
        handle = mono_ldtoken (D.28851, D.28850, &handle_class, iftmp.63);
        handle_class.64 = handle_class;
        mono_class_init (handle_class.64);
        D.28861 = mono_class_from_mono_type (handle);
        mono_class_init (D.28861);
        target = mono_type_get_object (domain, handle);
        goto <D.26080>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.26127>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28849 = patch_info->data.token;
        D.28851 = D.28849->image;
        D.28849 = patch_info->data.token;
        D.28850 = D.28849->token;
        D.28849 = patch_info->data.token;
        D.28856 = D.28849->has_context;
        if (D.28856 != 0) goto <D.28863>; else goto <D.28864>;
        <D.28863>:
        D.28849 = patch_info->data.token;
        iftmp.65 = &D.28849->context;
        goto <D.28865>;
        <D.28864>:
        iftmp.65 = 0B;
        <D.28865>:
        handle = mono_ldtoken (D.28851, D.28850, &handle_class, iftmp.65);
        handle_class.66 = handle_class;
        mono_class_init (handle_class.66);
        target = handle;
        goto <D.26080>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.26130>:
  D.28849 = patch_info->data.token;
  D.28851 = D.28849->image;
  D.28849 = patch_info->data.token;
  D.28850 = D.28849->token;
  D.28867 = mono_metadata_blob_heap (D.28851, D.28850);
  target = D.28867 + 2;
  goto <D.26080>;
  <D.26131>:
  D.28726 = patch_info->data.method;
  D.28868 = D.28726->flags;
  D.28869 = (int) D.28868;
  D.28870 = D.28869 & 8192;
  if (D.28870 != 0) goto <D.28871>; else goto <D.28872>;
  <D.28871>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.28873>; else goto <D.28874>;
        <D.28873>:
        D.28726 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.28726, &exc_class, &exc_arg);
        if (target == 0B) goto <D.28875>; else goto <D.28876>;
        <D.28875>:
        mono_aot_only.61 = mono_aot_only;
        if (mono_aot_only.61 != 0) goto <D.28877>; else goto <D.28878>;
        <D.28877>:
        D.28879 = mono_defaults.corlib;
        exc_class.67 = exc_class;
        exc_arg.68 = exc_arg;
        D.28882 = mono_exception_from_name_msg (D.28879, "System", exc_class.67, exc_arg.68);
        mono_raise_exception (D.28882);
        <D.28878>:
        D.28726 = patch_info->data.method;
        D.28883 = mono_method_full_name (D.28726, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.28883);
        <D.26134>:
        goto <D.26134>;
        <D.28876>:
        goto <D.28884>;
        <D.28874>:
        target = 0B;
        <D.28884>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.28885>;
  <D.28872>:
  D.28726 = patch_info->data.method;
  target = mono_lookup_internal_call (D.28726);
  if (target == 0B) goto <D.28886>; else goto <D.28887>;
  <D.28886>:
  if (run_cctors != 0) goto <D.28888>; else goto <D.28889>;
  <D.28888>:
  D.28726 = patch_info->data.method;
  D.28890 = mono_method_full_name (D.28726, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.28890);
  <D.26135>:
  goto <D.26135>;
  <D.28889>:
  <D.28887>:
  <D.28885>:
  goto <D.26080>;
  <D.26136>:
  target = mono_thread_interruption_request_flag ();
  goto <D.26080>;
  <D.26137>:
  {
    struct MonoVTable * vtable;

    D.28726 = patch_info->data.method;
    D.28891 = D.28726->klass;
    vtable = mono_class_vtable (domain, D.28891);
    D.28892 = vtable == 0B;
    D.28893 = (long int) D.28892;
    D.28894 = __builtin_expect (D.28893, 0);
    if (D.28894 != 0) goto <D.28895>; else goto <D.28896>;
    <D.28895>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.28896>:
    D.28726 = patch_info->data.method;
    D.28897 = mini_method_get_context (D.28726);
    D.28898 = D.28897->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.28898);
    goto <D.26080>;
  }
  <D.26139>:
  <D.26140>:
  <D.26141>:
  <D.26142>:
  goto <D.26080>;
  <D.26143>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.28899 = entry->data;
    D.28900 = D.28899->type;
    switch (D.28900) <default: <D.26163>, case 3: <D.26148>, case 6: <D.26149>, case 11: <D.26146>, case 13: <D.26150>, case 44: <D.26151>, case 45: <D.26152>, case 46: <D.26154>>
    <D.26146>:
    D.28901 = entry->method;
    D.28902 = entry->in_mrgctx;
    D.28899 = entry->data;
    D.28903 = D.28899->data.klass;
    D.28904 = &D.28903->byval_arg;
    D.28905 = entry->info_type;
    D.28901 = entry->method;
    D.28906 = mono_method_get_context (D.28901);
    slot = mono_method_lookup_or_register_info (D.28901, D.28902, D.28904, D.28905, D.28906);
    goto <D.26147>;
    <D.26148>:
    <D.26149>:
    D.28901 = entry->method;
    D.28902 = entry->in_mrgctx;
    D.28899 = entry->data;
    D.28907 = D.28899->data.method;
    D.28905 = entry->info_type;
    D.28901 = entry->method;
    D.28908 = mono_method_get_context (D.28901);
    slot = mono_method_lookup_or_register_info (D.28901, D.28902, D.28907, D.28905, D.28908);
    goto <D.26147>;
    <D.26150>:
    D.28901 = entry->method;
    D.28902 = entry->in_mrgctx;
    D.28899 = entry->data;
    D.28909 = D.28899->data.field;
    D.28905 = entry->info_type;
    D.28901 = entry->method;
    D.28910 = mono_method_get_context (D.28901);
    slot = mono_method_lookup_or_register_info (D.28901, D.28902, D.28909, D.28905, D.28910);
    goto <D.26147>;
    <D.26151>:
    D.28901 = entry->method;
    D.28902 = entry->in_mrgctx;
    D.28899 = entry->data;
    D.28911 = D.28899->data.sig;
    D.28905 = entry->info_type;
    D.28901 = entry->method;
    D.28912 = mono_method_get_context (D.28901);
    slot = mono_method_lookup_or_register_info (D.28901, D.28902, D.28911, D.28905, D.28912);
    goto <D.26147>;
    <D.26152>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (16);
      D.28899 = entry->data;
      D.28913 = D.28899->data.gsharedvt;
      memcpy (call_info, D.28913, 16);
      D.28901 = entry->method;
      D.28902 = entry->in_mrgctx;
      D.28905 = entry->info_type;
      D.28901 = entry->method;
      D.28914 = mono_method_get_context (D.28901);
      slot = mono_method_lookup_or_register_info (D.28901, D.28902, call_info, D.28905, D.28914);
      goto <D.26147>;
    }
    <D.26154>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.28899 = entry->data;
      oinfo = D.28899->data.gsharedvt_method;
      info = monoeg_malloc0 (16);
      D.28915 = oinfo->method;
      info->method = D.28915;
      D.28916 = monoeg_g_ptr_array_new ();
      info->entries = D.28916;
      i = 0;
      goto <D.26161>;
      <D.26160>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.28917 = oinfo->entries;
        D.28918 = D.28917->pdata;
        D.28919 = (long unsigned int) i;
        D.28920 = D.28919 * 8;
        D.28921 = D.28918 + D.28920;
        otemplate = *D.28921;
        template = monoeg_malloc0 (24);
        memcpy (template, otemplate, 24);
        D.28922 = info->entries;
        monoeg_g_ptr_array_add (D.28922, template);
      }
      i = i + 1;
      <D.26161>:
      D.28917 = oinfo->entries;
      D.28923 = D.28917->len;
      i.69 = (unsigned int) i;
      if (D.28923 > i.69) goto <D.26160>; else goto <D.26162>;
      <D.26162>:
      D.28901 = entry->method;
      D.28902 = entry->in_mrgctx;
      D.28905 = entry->info_type;
      D.28901 = entry->method;
      D.28925 = mono_method_get_context (D.28901);
      slot = mono_method_lookup_or_register_info (D.28901, D.28902, info, D.28905, D.28925);
      goto <D.26147>;
    }
    <D.26163>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.26147>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.26080>;
  }
  <D.26164>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.26080>;
  <D.26165>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.26080>;
  <D.26166>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.26080>;
  <D.26167>:
  if (run_cctors == 0) goto <D.28926>; else goto <D.28927>;
  <D.28926>:
  target = 0B;
  goto <D.28928>;
  <D.28927>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.28928>:
  goto <D.26080>;
  <D.26168>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3609);
  <D.26169>:
  {
    int card_table_shift_bits;
    void * card_table_mask;

    try
      {
        target = mono_gc_get_card_table (&card_table_shift_bits, &card_table_mask);
        goto <D.26080>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.26172>:
  target = mono_domain_alloc0 (domain, 8);
  goto <D.26080>;
  <D.26173>:
  mono_jit_tls_id.70 = mono_jit_tls_id;
  D.28930 = (long unsigned int) mono_jit_tls_id.70;
  target = (const void *) D.28930;
  goto <D.26080>;
  <D.26174>:
  {
    int offset;

    D.28931 = patch_info->data.target;
    D.28932 = (long int) D.28931;
    D.28933 = (<unnamed type>) D.28932;
    offset = mini_get_tls_offset (D.28933);
    D.28934 = (long int) offset;
    target = (const void *) D.28934;
    goto <D.26080>;
  }
  <D.26176>:
  target = 0B;
  goto <D.26080>;
  <D.26177>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.26080>:
  D.28826 = target;
  return D.28826;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.28941;
  struct GHashTable * D.28942;
  struct MonoJitDynamicMethodInfo * D.28946;
  struct MonoJitDynamicMethodInfo * res;

  D.28941 = domain->runtime_info;
  D.28942 = MEM[(struct MonoJitDomainInfo *)D.28941].dynamic_code_hash;
  if (D.28942 != 0B) goto <D.28943>; else goto <D.28944>;
  <D.28943>:
  D.28941 = domain->runtime_info;
  D.28942 = MEM[(struct MonoJitDomainInfo *)D.28941].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.28942, method);
  goto <D.28945>;
  <D.28944>:
  res = 0B;
  <D.28945>:
  D.28946 = res;
  return D.28946;
}


__attribute__((visibility ("hidden")))
mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  long int D.28948;
  struct GPtrArray * D.28949;
  struct MonoMemPool * D.28952;
  struct GSList * D.28953;
  struct GSList * D.28954;

  D.28948 = (long int) native_offset;
  ins->data.op[0].const_val = D.28948;
  D.28949 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.28949, ins);
  if (bb != 0B) goto <D.28950>; else goto <D.28951>;
  <D.28950>:
  D.28952 = cfg->mempool;
  D.28953 = bb->seq_points;
  D.28954 = g_slist_prepend_mempool (D.28952, D.28953, ins);
  bb->seq_points = D.28954;
  bb->last_seq_point = ins;
  <D.28951>:
}


__attribute__((visibility ("hidden")))
mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.28955;
  _Bool D.28958;
  long int D.28959;
  long int D.28960;
  struct MonoInst * * D.28963;
  struct MonoInst * D.28964;
  struct GSList * D.28967;
  struct GSList * D.28968;
  struct MonoInst * D.28970;
  struct GSList * D.28973;
  struct GSList * D.28974;
  struct MonoDwarfLocListEntry * entry;

  D.28955 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.28955, 20);
  if (is_reg != 0) goto <D.28956>; else goto <D.28957>;
  <D.28956>:
  D.28958 = offset != 0;
  D.28959 = (long int) D.28958;
  D.28960 = __builtin_expect (D.28959, 0);
  if (D.28960 != 0) goto <D.28961>; else goto <D.28962>;
  <D.28961>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.28962>:
  <D.28957>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.28963 = cfg->args;
  D.28964 = *D.28963;
  if (D.28964 == var) goto <D.28965>; else goto <D.28966>;
  <D.28965>:
  D.28955 = cfg->mempool;
  D.28967 = cfg->this_loclist;
  D.28968 = g_slist_append_mempool (D.28955, D.28967, entry);
  cfg->this_loclist = D.28968;
  goto <D.28969>;
  <D.28966>:
  D.28970 = cfg->rgctx_var;
  if (D.28970 == var) goto <D.28971>; else goto <D.28972>;
  <D.28971>:
  D.28955 = cfg->mempool;
  D.28973 = cfg->rgctx_loclist;
  D.28974 = g_slist_append_mempool (D.28955, D.28973, entry);
  cfg->rgctx_loclist = D.28974;
  <D.28972>:
  <D.28969>:
}


__attribute__((visibility ("hidden")))
mono_print_code (struct MonoCompile * cfg, const char * msg)
{
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.26216>;
  <D.26215>:
  mono_print_bb (bb, msg);
  bb = bb->next_bb;
  <D.26216>:
  if (bb != 0B) goto <D.26215>; else goto <D.26217>;
  <D.26217>:
}


__attribute__((visibility ("hidden")))
mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.71;
  unsigned int D.28979;
  unsigned int D.28980;
  long unsigned int D.28983;
  long unsigned int D.28984;
  unsigned int D.28989;
  unsigned int D.28990;
  struct MonoMethod * D.28993;
  unsigned int D.28994;
  int D.28995;
  struct MonoProfileCoverageInfo * D.28996;
  unsigned int D.28997;
  long int code.72;
  unsigned char * D.29001;
  long int D.29002;
  long int D.29003;
  unsigned int D.29004;
  unsigned int D.29005;
  int D.29006;
  int D.29007;
  unsigned int D.29008;
  unsigned int D.29009;
  int D.29010;
  struct MonoBasicBlock * D.29011;
  sizetype D.29016;
  unsigned int D.29017;
  _Bool D.29018;
  long int D.29019;
  long int D.29020;
  unsigned int max_epilog_size.73;
  unsigned int D.29024;
  long unsigned int D.29025;
  long unsigned int D.29026;
  void * D.29029;
  struct MonoJitDynamicMethodInfo * D.29030;
  struct MonoCodeManager * D.29031;
  struct MonoDomain * D.29032;
  union mono_mutex_t * D.29033;
  _Bool D.29036;
  long int D.29037;
  long int D.29038;
  _Bool D.29043;
  long int D.29044;
  long int D.29045;
  unsigned int D.29050;
  int D.29051;
  struct MonoCodeManager * D.29053;
  unsigned int D.29055;
  int D.29056;
  _Bool D.29057;
  long int D.29058;
  long int D.29059;
  long unsigned int D.29062;
  unsigned int D.29063;
  unsigned char * D.29066;
  char * D.29067;
  long unsigned int D.29070;
  struct MonoGenericContainer * D.29072;
  struct MonoClass * D.29074;
  struct MonoGenericContainer * D.29075;
  struct MonoGenericClass * D.29077;
  struct MonoGenericSharingContext * D.29078;
  _Bool D.29081;
  long int D.29082;
  long int D.29083;
  struct MonoJumpInfo * D.29086;
  struct MonoCodeManager * iftmp.74;
  <unnamed-unsigned:1> D.29091;
  int D.29092;
  int D.29097;
  int D.29100;
  struct MonoBasicBlock * bb;
  int max_epilog_size;
  guint8 * code;
  struct MonoDomain * code_domain;

  mono_using_xdebug.71 = mono_using_xdebug;
  if (mono_using_xdebug.71 != 0) goto <D.28976>; else goto <D.28977>;
  <D.28976>:
  code_domain = mono_get_root_domain ();
  goto <D.28978>;
  <D.28977>:
  code_domain = cfg->domain;
  <D.28978>:
  bb = cfg->bb_entry;
  goto <D.26313>;
  <D.26312>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.28979 = cfg->opt;
  D.28980 = D.28979 & 1;
  if (D.28980 != 0) goto <D.28981>; else goto <D.28982>;
  <D.28981>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.28982>:
  D.28983 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28984 = D.28983 & 524288;
  if (D.28984 == 0) goto <D.28985>; else goto <D.28986>;
  <D.28985>:
  mono_local_regalloc (cfg, bb);
  <D.28986>:
  D.28979 = cfg->opt;
  D.28980 = D.28979 & 1;
  if (D.28980 != 0) goto <D.28987>; else goto <D.28988>;
  <D.28987>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.28988>:
  bb = bb->next_bb;
  <D.26313>:
  if (bb != 0B) goto <D.26312>; else goto <D.26314>;
  <D.26314>:
  D.28989 = cfg->prof_options;
  D.28990 = D.28989 & 8192;
  if (D.28990 != 0) goto <D.28991>; else goto <D.28992>;
  <D.28991>:
  D.28993 = cfg->method;
  D.28994 = cfg->num_bblocks;
  D.28995 = (int) D.28994;
  D.28996 = mono_profiler_coverage_alloc (D.28993, D.28995);
  cfg->coverage_info = D.28996;
  <D.28992>:
  code = mono_arch_emit_prolog (cfg);
  D.28989 = cfg->prof_options;
  D.28997 = D.28989 & 4096;
  if (D.28997 != 0) goto <D.28998>; else goto <D.28999>;
  <D.28998>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.28999>:
  code.72 = (long int) code;
  D.29001 = cfg->native_code;
  D.29002 = (long int) D.29001;
  D.29003 = code.72 - D.29002;
  D.29004 = (unsigned int) D.29003;
  cfg->code_len = D.29004;
  D.29005 = cfg->code_len;
  cfg->prolog_end = D.29005;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.26316>;
  <D.26315>:
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  bb->native_offset = D.29006;
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  bb->real_native_offset = D.29006;
  mono_arch_output_basic_block (cfg, bb);
  D.29005 = cfg->code_len;
  D.29007 = bb->native_offset;
  D.29008 = (unsigned int) D.29007;
  D.29009 = D.29005 - D.29008;
  D.29010 = (int) D.29009;
  bb->native_length = D.29010;
  D.29011 = cfg->bb_exit;
  if (D.29011 == bb) goto <D.29012>; else goto <D.29013>;
  <D.29012>:
  D.29005 = cfg->code_len;
  cfg->epilog_begin = D.29005;
  D.28989 = cfg->prof_options;
  D.28997 = D.28989 & 4096;
  if (D.28997 != 0) goto <D.29014>; else goto <D.29015>;
  <D.29014>:
  D.29001 = cfg->native_code;
  D.29005 = cfg->code_len;
  D.29016 = (sizetype) D.29005;
  code = D.29001 + D.29016;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.72 = (long int) code;
  D.29001 = cfg->native_code;
  D.29002 = (long int) D.29001;
  D.29003 = code.72 - D.29002;
  D.29004 = (unsigned int) D.29003;
  cfg->code_len = D.29004;
  D.29005 = cfg->code_len;
  D.29017 = cfg->code_size;
  D.29018 = D.29005 >= D.29017;
  D.29019 = (long int) D.29018;
  D.29020 = __builtin_expect (D.29019, 0);
  if (D.29020 != 0) goto <D.29021>; else goto <D.29022>;
  <D.29021>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.29022>:
  <D.29015>:
  mono_arch_emit_epilog (cfg);
  <D.29013>:
  bb = bb->next_bb;
  <D.26316>:
  if (bb != 0B) goto <D.26315>; else goto <D.26317>;
  <D.26317>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.29005 = cfg->code_len;
  max_epilog_size.73 = (unsigned int) max_epilog_size;
  D.29024 = D.29005 + max_epilog_size.73;
  cfg->code_size = D.29024;
  D.28993 = cfg->method;
  D.29025 = BIT_FIELD_REF <*D.28993, 64, 256>;
  D.29026 = D.29025 & 18014398509481984;
  if (D.29026 != 0) goto <D.29027>; else goto <D.29028>;
  <D.29027>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29029 = monoeg_malloc0 (16);
    cfg->dynamic_info = D.29029;
    D.29030 = cfg->dynamic_info;
    D.29031 = mono_code_manager_new_dynamic ();
    D.29030->code_mp = D.29031;
    {
      int ret;

      D.29032 = cfg->domain;
      D.29033 = &D.29032->lock.mutex;
      ret = pthread_mutex_lock (D.29033);
      if (ret != 0) goto <D.29034>; else goto <D.29035>;
      <D.29034>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29035>:
      D.29036 = ret != 0;
      D.29037 = (long int) D.29036;
      D.29038 = __builtin_expect (D.29037, 0);
      if (D.29038 != 0) goto <D.29039>; else goto <D.29040>;
      <D.29039>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.29040>:
    }
    D.29032 = cfg->domain;
    D.28993 = cfg->method;
    D.29030 = cfg->dynamic_info;
    mono_dynamic_code_hash_insert (D.29032, D.28993, D.29030);
    {
      int ret;

      D.29032 = cfg->domain;
      D.29033 = &D.29032->lock.mutex;
      ret = pthread_mutex_unlock (D.29033);
      if (ret != 0) goto <D.29041>; else goto <D.29042>;
      <D.29041>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29042>:
      D.29043 = ret != 0;
      D.29044 = (long int) D.29043;
      D.29045 = __builtin_expect (D.29044, 0);
      if (D.29045 != 0) goto <D.29046>; else goto <D.29047>;
      <D.29046>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.29047>:
    }
    mono_using_xdebug.71 = mono_using_xdebug;
    if (mono_using_xdebug.71 != 0) goto <D.29048>; else goto <D.29049>;
    <D.29048>:
    D.29017 = cfg->code_size;
    D.29050 = D.29017 + unwindlen;
    D.29051 = (int) D.29050;
    code = mono_domain_code_reserve (code_domain, D.29051);
    goto <D.29052>;
    <D.29049>:
    D.29030 = cfg->dynamic_info;
    D.29053 = D.29030->code_mp;
    D.29017 = cfg->code_size;
    D.29050 = D.29017 + unwindlen;
    D.29051 = (int) D.29050;
    code = mono_code_manager_reserve (D.29053, D.29051);
    <D.29052>:
  }
  goto <D.29054>;
  <D.29028>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29017 = cfg->code_size;
    D.29055 = D.29017 + unwindlen;
    D.29056 = (int) D.29055;
    code = mono_domain_code_reserve (code_domain, D.29056);
  }
  <D.29054>:
  D.29057 = code == 0B;
  D.29058 = (long int) D.29057;
  D.29059 = __builtin_expect (D.29058, 0);
  if (D.29059 != 0) goto <D.29060>; else goto <D.29061>;
  <D.29060>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.29061>:
  D.29001 = cfg->native_code;
  D.29005 = cfg->code_len;
  D.29062 = (long unsigned int) D.29005;
  memcpy (code, D.29001, D.29062);
  D.29001 = cfg->native_code;
  monoeg_g_free (D.29001);
  cfg->native_code = code;
  D.29001 = cfg->native_code;
  D.29005 = cfg->code_len;
  D.29016 = (sizetype) D.29005;
  code = D.29001 + D.29016;
  mono_postprocess_patches (cfg);
  D.29063 = cfg->verbose_level;
  if (D.29063 != 0) goto <D.29064>; else goto <D.29065>;
  <D.29064>:
  {
    char * nm;

    D.28993 = cfg->method;
    nm = mono_method_full_name (D.28993, 1);
    D.29001 = cfg->native_code;
    D.29001 = cfg->native_code;
    D.29005 = cfg->code_len;
    D.29016 = (sizetype) D.29005;
    D.29066 = D.29001 + D.29016;
    D.29005 = cfg->code_len;
    D.29032 = cfg->domain;
    D.29067 = D.29032->friendly_name;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.29001, D.29066, D.29005, D.29067);
    monoeg_g_free (nm);
  }
  <D.29065>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.28993 = cfg->method;
    D.29025 = BIT_FIELD_REF <*D.28993, 64, 256>;
    D.29070 = D.29025 & 2251799813685248;
    if (D.29070 != 0) goto <D.29068>; else goto <D.29071>;
    <D.29071>:
    D.28993 = cfg->method;
    D.29072 = mono_method_get_generic_container (D.28993);
    if (D.29072 != 0B) goto <D.29068>; else goto <D.29073>;
    <D.29073>:
    D.28993 = cfg->method;
    D.29074 = D.28993->klass;
    D.29075 = D.29074->generic_container;
    if (D.29075 != 0B) goto <D.29068>; else goto <D.29076>;
    <D.29076>:
    D.28993 = cfg->method;
    D.29074 = D.28993->klass;
    D.29077 = D.29074->generic_class;
    if (D.29077 != 0B) goto <D.29068>; else goto <D.29069>;
    <D.29068>:
    is_generic = 1;
    <D.29069>:
    D.29078 = cfg->generic_sharing_context;
    if (D.29078 != 0B) goto <D.29079>; else goto <D.29080>;
    <D.29079>:
    D.29081 = is_generic == 0;
    D.29082 = (long int) D.29081;
    D.29083 = __builtin_expect (D.29082, 0);
    if (D.29083 != 0) goto <D.29084>; else goto <D.29085>;
    <D.29084>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.29085>:
    <D.29080>:
  }
  D.28993 = cfg->method;
  D.29032 = cfg->domain;
  D.29001 = cfg->native_code;
  D.29086 = cfg->patch_info;
  D.29030 = cfg->dynamic_info;
  if (D.29030 != 0B) goto <D.29088>; else goto <D.29089>;
  <D.29088>:
  D.29030 = cfg->dynamic_info;
  iftmp.74 = D.29030->code_mp;
  goto <D.29090>;
  <D.29089>:
  iftmp.74 = 0B;
  <D.29090>:
  D.29091 = cfg->run_cctors;
  D.29092 = (int) D.29091;
  mono_arch_patch_code (D.28993, D.29032, D.29001, D.29086, iftmp.74, D.29092);
  D.28993 = cfg->method;
  D.29025 = BIT_FIELD_REF <*D.28993, 64, 256>;
  D.29026 = D.29025 & 18014398509481984;
  if (D.29026 != 0) goto <D.29093>; else goto <D.29094>;
  <D.29093>:
  mono_using_xdebug.71 = mono_using_xdebug;
  if (mono_using_xdebug.71 != 0) goto <D.29095>; else goto <D.29096>;
  <D.29095>:
  D.29001 = cfg->native_code;
  D.29017 = cfg->code_size;
  D.29097 = (int) D.29017;
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  mono_domain_code_commit (code_domain, D.29001, D.29097, D.29006);
  goto <D.29098>;
  <D.29096>:
  D.29030 = cfg->dynamic_info;
  D.29053 = D.29030->code_mp;
  D.29001 = cfg->native_code;
  D.29017 = cfg->code_size;
  D.29097 = (int) D.29017;
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  mono_code_manager_commit (D.29053, D.29001, D.29097, D.29006);
  <D.29098>:
  goto <D.29099>;
  <D.29094>:
  D.29001 = cfg->native_code;
  D.29017 = cfg->code_size;
  D.29097 = (int) D.29017;
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  mono_domain_code_commit (code_domain, D.29001, D.29097, D.29006);
  <D.29099>:
  D.29001 = cfg->native_code;
  D.29005 = cfg->code_len;
  D.29006 = (int) D.29005;
  D.28993 = cfg->method;
  mono_profiler_code_buffer_new (D.29001, D.29006, 1, D.28993);
  D.29001 = cfg->native_code;
  D.29005 = cfg->code_len;
  D.29100 = (int) D.29005;
  mono_arch_flush_icache (D.29001, D.29100);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.29101;
  struct GHashTable * D.29102;
  struct GHashTable * D.29105;

  D.29101 = domain->runtime_info;
  D.29102 = MEM[(struct MonoJitDomainInfo *)D.29101].dynamic_code_hash;
  if (D.29102 == 0B) goto <D.29103>; else goto <D.29104>;
  <D.29103>:
  D.29101 = domain->runtime_info;
  D.29105 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.29101].dynamic_code_hash = D.29105;
  <D.29104>:
  D.29101 = domain->runtime_info;
  D.29102 = MEM[(struct MonoJitDomainInfo *)D.29101].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.29102, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.29106;
  const void * D.29107;
  const char * D.29110;
  char * D.29111;
  char * D.29114;
  struct GHashTable * D.29119;
  <unnamed type> D.29124;
  const void * D.29125;
  struct MonoMethod * D.29126;
  long unsigned int D.29127;
  long unsigned int D.29128;
  struct MonoJitDynamicMethodInfo * D.29131;
  struct MonoCodeManager * D.29132;
  struct MonoJumpInfoBBTable * D.29133;
  int D.29134;
  unsigned int D.29135;
  unsigned int D.29136;
  int D.29137;
  struct MonoDomain * D.29139;
  struct MonoBasicBlock * * D.29140;
  long unsigned int D.29141;
  long unsigned int D.29142;
  struct MonoBasicBlock * * D.29143;
  struct MonoBasicBlock * D.29144;
  int D.29147;
  _Bool D.29148;
  long int D.29149;
  long int D.29150;
  void * * D.29153;
  long int D.29154;
  void * D.29155;
  unsigned char * D.29157;
  int D.29158;
  sizetype D.29159;
  union mono_mutex_t * D.29160;
  _Bool D.29163;
  long int D.29164;
  long int D.29165;
  void * D.29168;
  struct GHashTable * D.29169;
  struct MonoMethod * D.29170;
  struct GSList * D.29173;
  struct GSList * D.29174;
  _Bool D.29177;
  long int D.29178;
  long int D.29179;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.26240>;
  <D.26239>:
  D.29106 = patch_info->type;
  switch (D.29106) <default: <D.26238>, case 1: <D.26223>, case 4: <D.26232>, case 8: <D.26227>>
  <D.26223>:
  {
    struct MonoJitICallInfo * info;

    D.29107 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.29107);
    if (info != 0B) goto <D.29108>; else goto <D.29109>;
    <D.29108>:
    D.29110 = info->name;
    D.29111 = strstr (D.29110, "ves_array_new_va_");
    if (D.29111 == 0B) goto <D.29112>; else goto <D.29113>;
    <D.29112>:
    D.29110 = info->name;
    D.29114 = strstr (D.29110, "ves_array_element_address_");
    if (D.29114 == 0B) goto <D.29115>; else goto <D.29116>;
    <D.29115>:
    patch_info->type = 7;
    D.29110 = info->name;
    patch_info->data.name = D.29110;
    <D.29116>:
    <D.29113>:
    <D.29109>:
    D.29106 = patch_info->type;
    if (D.29106 == 1) goto <D.29117>; else goto <D.29118>;
    <D.29117>:
    D.29119 = cfg->abs_patches;
    if (D.29119 != 0B) goto <D.29120>; else goto <D.29121>;
    <D.29120>:
    {
      struct MonoJumpInfo * abs_ji;

      D.29119 = cfg->abs_patches;
      D.29107 = patch_info->data.target;
      abs_ji = monoeg_g_hash_table_lookup (D.29119, D.29107);
      if (abs_ji != 0B) goto <D.29122>; else goto <D.29123>;
      <D.29122>:
      D.29124 = abs_ji->type;
      patch_info->type = D.29124;
      D.29125 = abs_ji->data.target;
      patch_info->data.target = D.29125;
      <D.29123>:
    }
    <D.29121>:
    <D.29118>:
    goto <D.26226>;
  }
  <D.26227>:
  {
    void * * table;

    D.29126 = cfg->method;
    D.29127 = BIT_FIELD_REF <*D.29126, 64, 256>;
    D.29128 = D.29127 & 18014398509481984;
    if (D.29128 != 0) goto <D.29129>; else goto <D.29130>;
    <D.29129>:
    D.29131 = cfg->dynamic_info;
    D.29132 = D.29131->code_mp;
    D.29133 = patch_info->data.table;
    D.29134 = D.29133->table_size;
    D.29135 = (unsigned int) D.29134;
    D.29136 = D.29135 * 8;
    D.29137 = (int) D.29136;
    table = mono_code_manager_reserve (D.29132, D.29137);
    goto <D.29138>;
    <D.29130>:
    D.29139 = cfg->domain;
    D.29133 = patch_info->data.table;
    D.29134 = D.29133->table_size;
    D.29135 = (unsigned int) D.29134;
    D.29136 = D.29135 * 8;
    D.29137 = (int) D.29136;
    table = mono_domain_code_reserve (D.29139, D.29137);
    <D.29138>:
    i = 0;
    goto <D.26230>;
    <D.26229>:
    D.29133 = patch_info->data.table;
    D.29140 = D.29133->table;
    D.29141 = (long unsigned int) i;
    D.29142 = D.29141 * 8;
    D.29143 = D.29140 + D.29142;
    D.29144 = *D.29143;
    if (D.29144 != 0B) goto <D.29145>; else goto <D.29146>;
    <D.29145>:
    D.29133 = patch_info->data.table;
    D.29140 = D.29133->table;
    D.29141 = (long unsigned int) i;
    D.29142 = D.29141 * 8;
    D.29143 = D.29140 + D.29142;
    D.29144 = *D.29143;
    D.29147 = D.29144->native_offset;
    D.29148 = D.29147 == 0;
    D.29149 = (long int) D.29148;
    D.29150 = __builtin_expect (D.29149, 0);
    if (D.29150 != 0) goto <D.29151>; else goto <D.29152>;
    <D.29151>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.29152>:
    D.29141 = (long unsigned int) i;
    D.29142 = D.29141 * 8;
    D.29153 = table + D.29142;
    D.29133 = patch_info->data.table;
    D.29140 = D.29133->table;
    D.29141 = (long unsigned int) i;
    D.29142 = D.29141 * 8;
    D.29143 = D.29140 + D.29142;
    D.29144 = *D.29143;
    D.29147 = D.29144->native_offset;
    D.29154 = (long int) D.29147;
    D.29155 = (void *) D.29154;
    *D.29153 = D.29155;
    goto <D.29156>;
    <D.29146>:
    D.29141 = (long unsigned int) i;
    D.29142 = D.29141 * 8;
    D.29153 = table + D.29142;
    *D.29153 = 0B;
    <D.29156>:
    i = i + 1;
    <D.26230>:
    D.29133 = patch_info->data.table;
    D.29134 = D.29133->table_size;
    if (D.29134 > i) goto <D.26229>; else goto <D.26231>;
    <D.26231>:
    D.29133 = patch_info->data.table;
    D.29133->table = table;
    goto <D.26226>;
  }
  <D.26232>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.29157 = cfg->native_code;
    D.29158 = patch_info->ip.i;
    D.29159 = (sizetype) D.29158;
    ip = D.29157 + D.29159;
    {
      int ret;

      D.29160 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.29160);
      if (ret != 0) goto <D.29161>; else goto <D.29162>;
      <D.29161>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29162>:
      D.29163 = ret != 0;
      D.29164 = (long int) D.29163;
      D.29165 = __builtin_expect (D.29164, 0);
      if (D.29165 != 0) goto <D.29166>; else goto <D.29167>;
      <D.29166>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.29167>:
    }
    D.29168 = domain->runtime_info;
    D.29169 = MEM[(struct MonoJitDomainInfo *)D.29168].jump_target_hash;
    D.29170 = patch_info->data.method;
    jlist = monoeg_g_hash_table_lookup (D.29169, D.29170);
    if (jlist == 0B) goto <D.29171>; else goto <D.29172>;
    <D.29171>:
    jlist = mono_domain_alloc0 (domain, 8);
    D.29168 = domain->runtime_info;
    D.29169 = MEM[(struct MonoJitDomainInfo *)D.29168].jump_target_hash;
    D.29170 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.29169, D.29170, jlist, 0);
    <D.29172>:
    D.29173 = jlist->list;
    D.29174 = monoeg_g_slist_prepend (D.29173, ip);
    jlist->list = D.29174;
    {
      int ret;

      D.29160 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.29160);
      if (ret != 0) goto <D.29175>; else goto <D.29176>;
      <D.29175>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29176>:
      D.29177 = ret != 0;
      D.29178 = (long int) D.29177;
      D.29179 = __builtin_expect (D.29178, 0);
      if (D.29179 != 0) goto <D.29180>; else goto <D.29181>;
      <D.29180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3842, "ret == 0");
      <D.29181>:
    }
    goto <D.26226>;
  }
  <D.26238>:
  goto <D.26226>;
  <D.26226>:
  patch_info = patch_info->next;
  <D.26240>:
  if (patch_info != 0B) goto <D.26239>; else goto <D.26241>;
  <D.26241>:
}


__attribute__((visibility ("hidden")))
mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  long unsigned int D.29186;
  long unsigned int D.29187;
  struct MonoClass * D.29189;
  struct MonoGenericContainer * D.29190;
  long unsigned int D.29192;
  long unsigned int D.29193;
  long unsigned int D.29194;
  struct MonoGenericContainer * D.29197;
  struct MonoClass * D.29199;
  struct MonoGenericContainer * D.29200;
  int D.29206;
  int D.29208;
  int iftmp.75;
  int D.29215;
  struct MonoGenericInst * D.29221;
  struct MonoGenericInst * D.29222;
  struct MonoGenericInst * D.29228;
  struct MonoGenericInst * D.29229;
  struct MonoClass * D.29232;
  long unsigned int D.29233;
  long unsigned int D.29234;
  _Bool D.29235;
  long int D.29236;
  long int D.29237;
  struct MonoMethod * D.29240;
  struct MonoGenericContext shared_context;
  struct MonoMethod * declaring_method;
  struct MonoMethod * res;
  gboolean partial;
  gboolean gsharedvt;
  struct MonoGenericContainer * class_container;
  struct MonoGenericContainer * method_container;

  try
    {
      partial = 0;
      gsharedvt = 0;
      method_container = 0B;
      D.29186 = BIT_FIELD_REF <*method, 64, 256>;
      D.29187 = D.29186 & 4503599627370496;
      if (D.29187 != 0) goto <D.29183>; else goto <D.29188>;
      <D.29188>:
      D.29189 = method->klass;
      D.29190 = D.29189->generic_container;
      if (D.29190 != 0B) goto <D.29191>; else goto <D.29184>;
      <D.29191>:
      D.29186 = BIT_FIELD_REF <*method, 64, 256>;
      D.29192 = D.29186 & 2251799813685248;
      if (D.29192 == 0) goto <D.29183>; else goto <D.29184>;
      <D.29183>:
      declaring_method = method;
      goto <D.29185>;
      <D.29184>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.29185>:
      D.29193 = BIT_FIELD_REF <*declaring_method, 64, 256>;
      D.29194 = D.29193 & 4503599627370496;
      if (D.29194 != 0) goto <D.29195>; else goto <D.29196>;
      <D.29195>:
      D.29197 = mono_method_get_generic_container (declaring_method);
      shared_context = D.29197->context;
      goto <D.29198>;
      <D.29196>:
      D.29199 = declaring_method->klass;
      D.29200 = D.29199->generic_container;
      shared_context = D.29200->context;
      <D.29198>:
      if (method != declaring_method) goto <D.29204>; else goto <D.29201>;
      <D.29204>:
      D.29186 = BIT_FIELD_REF <*method, 64, 256>;
      D.29192 = D.29186 & 2251799813685248;
      if (D.29192 != 0) goto <D.29205>; else goto <D.29201>;
      <D.29205>:
      D.29206 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29206 == 0) goto <D.29202>; else goto <D.29201>;
      <D.29201>:
      if (is_gsharedvt != 0) goto <D.29202>; else goto <D.29207>;
      <D.29207>:
      D.29208 = mini_is_gsharedvt_sharable_method (method);
      if (D.29208 != 0) goto <D.29202>; else goto <D.29203>;
      <D.29202>:
      {
        struct MonoGenericContext * context;
        struct MonoGenericInst * inst;

        context = mono_method_get_context (method);
        partial = mono_method_is_generic_sharable_full (method, 0, 1, 0);
        if (is_gsharedvt != 0) goto <D.29210>; else goto <D.29213>;
        <D.29213>:
        if (partial == 0) goto <D.29214>; else goto <D.29211>;
        <D.29214>:
        D.29215 = mini_is_gsharedvt_sharable_method (method);
        if (D.29215 != 0) goto <D.29210>; else goto <D.29211>;
        <D.29210>:
        iftmp.75 = 1;
        goto <D.29212>;
        <D.29211>:
        iftmp.75 = 0;
        <D.29212>:
        gsharedvt = iftmp.75;
        D.29199 = declaring_method->klass;
        class_container = D.29199->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.29216>; else goto <D.29217>;
        <D.29216>:
        inst = context->class_inst;
        goto <D.29218>;
        <D.29217>:
        inst = shared_context.class_inst;
        <D.29218>:
        if (inst != 0B) goto <D.29219>; else goto <D.29220>;
        <D.29219>:
        D.29221 = shared_context.class_inst;
        D.29222 = get_shared_inst (inst, D.29221, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.29222;
        <D.29220>:
        if (context != 0B) goto <D.29223>; else goto <D.29224>;
        <D.29223>:
        inst = context->method_inst;
        goto <D.29225>;
        <D.29224>:
        inst = shared_context.method_inst;
        <D.29225>:
        if (inst != 0B) goto <D.29226>; else goto <D.29227>;
        <D.29226>:
        D.29228 = shared_context.method_inst;
        D.29229 = get_shared_inst (inst, D.29228, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.29229;
        <D.29227>:
        partial = 1;
      }
      <D.29203>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.29230>; else goto <D.29231>;
      <D.29230>:
      D.29232 = res->klass;
      D.29233 = BIT_FIELD_REF <*D.29232, 64, 256>;
      D.29234 = D.29233 & 268435456;
      D.29235 = D.29234 != 0;
      D.29236 = (long int) D.29235;
      D.29237 = __builtin_expect (D.29236, 0);
      if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
      <D.29238>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.29239>:
      <D.29231>:
      D.29240 = res;
      return D.29240;
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


get_shared_inst (struct MonoGenericInst * inst, struct MonoGenericInst * shared_inst, struct MonoGenericContainer * container, gboolean all_vt, gboolean gsharedvt)
{
  <unnamed-unsigned:22> D.29243;
  long unsigned int D.29244;
  long unsigned int D.29245;
  struct MonoType * D.29250;
  int D.29251;
  unsigned char D.29253;
  long unsigned int D.29255;
  long unsigned int D.29256;
  struct MonoType * * D.29257;
  struct MonoType * D.29258;
  struct MonoType * D.29261;
  struct MonoType * D.29265;
  int D.29267;
  struct MonoGenericInst * D.29268;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.29243 = inst->type_argc;
  D.29244 = (long unsigned int) D.29243;
  D.29245 = D.29244 * 8;
  type_argv = monoeg_malloc0 (D.29245);
  i = 0;
  goto <D.26465>;
  <D.26464>:
  if (all_vt == 0) goto <D.29249>; else goto <D.29246>;
  <D.29249>:
  D.29250 = inst->type_argv[i];
  D.29251 = mono_type_is_reference (D.29250);
  if (D.29251 != 0) goto <D.29247>; else goto <D.29252>;
  <D.29252>:
  D.29250 = inst->type_argv[i];
  D.29253 = D.29250->type;
  if (D.29253 == 19) goto <D.29247>; else goto <D.29254>;
  <D.29254>:
  D.29250 = inst->type_argv[i];
  D.29253 = D.29250->type;
  if (D.29253 == 30) goto <D.29247>; else goto <D.29246>;
  <D.29247>:
  D.29255 = (long unsigned int) i;
  D.29256 = D.29255 * 8;
  D.29257 = type_argv + D.29256;
  D.29258 = shared_inst->type_argv[i];
  *D.29257 = D.29258;
  goto <D.29248>;
  <D.29246>:
  if (all_vt != 0) goto <D.29259>; else goto <D.29260>;
  <D.29259>:
  D.29255 = (long unsigned int) i;
  D.29256 = D.29255 * 8;
  D.29257 = type_argv + D.29256;
  D.29258 = shared_inst->type_argv[i];
  D.29261 = get_gsharedvt_type (D.29258);
  *D.29257 = D.29261;
  goto <D.29262>;
  <D.29260>:
  if (gsharedvt != 0) goto <D.29263>; else goto <D.29264>;
  <D.29263>:
  D.29255 = (long unsigned int) i;
  D.29256 = D.29255 * 8;
  D.29257 = type_argv + D.29256;
  D.29258 = shared_inst->type_argv[i];
  D.29265 = get_gsharedvt_type (D.29258);
  *D.29257 = D.29265;
  goto <D.29266>;
  <D.29264>:
  D.29255 = (long unsigned int) i;
  D.29256 = D.29255 * 8;
  D.29257 = type_argv + D.29256;
  D.29250 = inst->type_argv[i];
  *D.29257 = D.29250;
  <D.29266>:
  <D.29262>:
  <D.29248>:
  i = i + 1;
  <D.26465>:
  D.29243 = inst->type_argc;
  D.29267 = (int) D.29243;
  if (D.29267 > i) goto <D.26464>; else goto <D.26466>;
  <D.26466>:
  D.29243 = inst->type_argc;
  D.29267 = (int) D.29243;
  res = mono_metadata_get_generic_inst (D.29267, type_argv);
  monoeg_g_free (type_argv);
  D.29268 = res;
  return D.29268;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.76;
  struct MonoGenericContainer * D.29274;
  struct MonoGenericParamInfo * D.29276;
  _Bool D.29277;
  long int D.29278;
  long int D.29279;
  struct GHashTable * D.29284;
  struct GHashTable * D.29287;
  struct MonoType * D.29290;
  struct MonoImage * D.29292;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.29274 = par->owner;
  if (D.29274 == 0B) goto <D.29271>; else goto <D.29275>;
  <D.29275>:
  D.29276 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.29276 == 0B) goto <D.29271>; else goto <D.29272>;
  <D.29271>:
  iftmp.76 = 1;
  goto <D.29273>;
  <D.29272>:
  iftmp.76 = 0;
  <D.29273>:
  D.29277 = iftmp.76 != 0;
  D.29278 = (long int) D.29277;
  D.29279 = __builtin_expect (D.29278, 0);
  if (D.29279 != 0) goto <D.29280>; else goto <D.29281>;
  <D.29280>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.29281>:
  D.29274 = par->owner;
  if (D.29274 != 0B) goto <D.29282>; else goto <D.29283>;
  <D.29282>:
  D.29274 = par->owner;
  image = D.29274->image;
  mono_image_lock (image);
  D.29284 = image->gsharedvt_types;
  if (D.29284 == 0B) goto <D.29285>; else goto <D.29286>;
  <D.29285>:
  D.29287 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.29287;
  <D.29286>:
  D.29284 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.29284, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.29288>; else goto <D.29289>;
  <D.29288>:
  D.29290 = res;
  return D.29290;
  <D.29289>:
  copy = mono_image_alloc0 (image, 56);
  memcpy (copy, par, 56);
  goto <D.29291>;
  <D.29283>:
  copy = monoeg_g_memdup (par, 56);
  <D.29291>:
  copy->owner = 0B;
  D.29292 = mono_defaults.corlib;
  copy->image = D.29292;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.29274 = par->owner;
  if (D.29274 != 0B) goto <D.29293>; else goto <D.29294>;
  <D.29293>:
  mono_image_lock (image);
  D.29284 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.29284, par, res, 0);
  mono_image_unlock (image);
  <D.29294>:
  D.29290 = res;
  return D.29290;
}


__attribute__((visibility ("hidden")))
mini_get_shared_method (struct MonoMethod * method)
{
  struct MonoMethod * D.29296;

  D.29296 = mini_get_shared_method_full (method, 0, 0);
  return D.29296;
}


__attribute__((visibility ("hidden")))
mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.29298;
  <unnamed-unsigned:22> D.29301;
  long unsigned int D.29302;
  long unsigned int D.29303;
  void * D.29304;
  unsigned char D.29307;
  struct MonoGenericParam * D.29309;
  short unsigned int D.29310;
  gboolean * D.29313;
  long unsigned int D.29314;
  long unsigned int D.29315;
  gboolean * D.29316;
  int D.29317;
  struct MonoGenericInst * D.29318;
  void * D.29321;
  unsigned char D.29324;
  struct MonoGenericParam * D.29326;
  short unsigned int D.29327;
  gboolean * D.29330;
  gboolean * D.29331;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 16);
  D.29298 = context->class_inst;
  if (D.29298 != 0B) goto <D.29299>; else goto <D.29300>;
  <D.29299>:
  inst = context->class_inst;
  D.29301 = inst->type_argc;
  D.29302 = (long unsigned int) D.29301;
  D.29303 = D.29302 * 4;
  D.29304 = monoeg_malloc0 (D.29303);
  gsctx->var_is_vt = D.29304;
  i = 0;
  goto <D.26492>;
  <D.26491>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29307 = type->type;
    if (D.29307 == 19) goto <D.29305>; else goto <D.29308>;
    <D.29308>:
    D.29307 = type->type;
    if (D.29307 == 30) goto <D.29305>; else goto <D.29306>;
    <D.29305>:
    D.29309 = type->data.generic_param;
    D.29310 = D.29309->serial;
    if (D.29310 == 1) goto <D.29311>; else goto <D.29312>;
    <D.29311>:
    D.29313 = gsctx->var_is_vt;
    D.29314 = (long unsigned int) i;
    D.29315 = D.29314 * 4;
    D.29316 = D.29313 + D.29315;
    *D.29316 = 1;
    <D.29312>:
    <D.29306>:
  }
  i = i + 1;
  <D.26492>:
  D.29301 = inst->type_argc;
  D.29317 = (int) D.29301;
  if (D.29317 > i) goto <D.26491>; else goto <D.26493>;
  <D.26493>:
  <D.29300>:
  D.29318 = context->method_inst;
  if (D.29318 != 0B) goto <D.29319>; else goto <D.29320>;
  <D.29319>:
  inst = context->method_inst;
  D.29301 = inst->type_argc;
  D.29302 = (long unsigned int) D.29301;
  D.29303 = D.29302 * 4;
  D.29321 = monoeg_malloc0 (D.29303);
  gsctx->mvar_is_vt = D.29321;
  i = 0;
  goto <D.26496>;
  <D.26495>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29324 = type->type;
    if (D.29324 == 19) goto <D.29322>; else goto <D.29325>;
    <D.29325>:
    D.29324 = type->type;
    if (D.29324 == 30) goto <D.29322>; else goto <D.29323>;
    <D.29322>:
    D.29326 = type->data.generic_param;
    D.29327 = D.29326->serial;
    if (D.29327 == 1) goto <D.29328>; else goto <D.29329>;
    <D.29328>:
    D.29330 = gsctx->mvar_is_vt;
    D.29314 = (long unsigned int) i;
    D.29315 = D.29314 * 4;
    D.29331 = D.29330 + D.29315;
    *D.29331 = 1;
    <D.29329>:
    <D.29323>:
  }
  i = i + 1;
  <D.26496>:
  D.29301 = inst->type_argc;
  D.29317 = (int) D.29301;
  if (D.29317 > i) goto <D.26495>; else goto <D.26497>;
  <D.26497>:
  <D.29320>:
}


__attribute__((visibility ("hidden")))
mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.29332;
  _Bool D.29333;
  unsigned int D.29334;
  _Bool D.29335;
  unsigned int D.29336;
  _Bool D.29337;
  <unnamed type> D.29338;
  unsigned int D.29339;
  int iftmp.77;
  struct MonoClass * D.29350;
  int D.29351;
  unsigned int D.29353;
  long unsigned int D.29355;
  long unsigned int D.29356;
  struct MonoGenericContainer * D.29358;
  struct MonoGenericClass * D.29360;
  int D.29362;
  int iftmp.78;
  int D.29367;
  int D.29370;
  long unsigned int D.29376;
  long unsigned int D.29377;
  int D.29379;
  long unsigned int D.29382;
  long unsigned int D.29383;
  int D.29384;
  int D.29387;
  int D.29394;
  int D.29397;
  _Bool D.29398;
  long int D.29399;
  long int D.29400;
  _Bool D.29408;
  long int D.29409;
  long int D.29410;
  struct MonoMethod * D.29414;
  struct MonoMethodHeader * D.29415;
  struct MonoMemPool * D.29416;
  <unnamed type> D.29417;
  unsigned char D.29418;
  <unnamed-unsigned:1> D.29419;
  int mini_verbose.79;
  unsigned int mini_verbose.80;
  unsigned char D.29422;
  <unnamed-unsigned:1> D.29423;
  unsigned char D.29424;
  <unnamed-unsigned:1> D.29425;
  <unnamed-unsigned:1> D.29426;
  int D.29427;
  unsigned char D.29428;
  <unnamed-unsigned:1> D.29429;
  int D.29430;
  unsigned char D.29431;
  <unnamed-unsigned:1> D.29432;
  int D.29433;
  unsigned char D.29434;
  <unnamed-unsigned:1> D.29435;
  struct MonoGenericSharingContext * D.29438;
  unsigned char D.29439;
  <unnamed-unsigned:1> D.29440;
  struct GHashTable * D.29441;
  long unsigned int D.29442;
  long unsigned int D.29443;
  struct GPtrArray * D.29446;
  long unsigned int D.29449;
  long unsigned int D.29450;
  struct MonoCompile * D.29457;
  struct MonoGenericSharingContext * D.29460;
  int D.29463;
  long unsigned int D.29467;
  _Bool D.29468;
  long int D.29469;
  long int D.29470;
  long unsigned int D.29476;
  long unsigned int D.29477;
  _Bool D.29478;
  long int D.29479;
  long int D.29480;
  _Bool D.29486;
  long int D.29487;
  long int D.29488;
  const char * D.29493;
  gchar * D.29494;
  unsigned char D.29501;
  unsigned int D.29502;
  const char * D.29504;
  gchar * D.29505;
  int D.29508;
  unsigned int D.29511;
  unsigned int D.29512;
  unsigned int D.29513;
  unsigned int D.29514;
  unsigned int D.29515;
  int mono_using_xdebug.81;
  unsigned int D.29521;
  const gchar * D.29522;
  char * D.29528;
  char * D.29530;
  int D.29531;
  const gchar * D.29534;
  int D.29535;
  struct MonoMemPool * D.29538;
  <unnamed-unsigned:15> D.29539;
  unsigned int D.29540;
  unsigned int D.29541;
  void * D.29542;
  unsigned int D.29543;
  const char * iftmp.82;
  int D.29547;
  const char * iftmp.83;
  unsigned int D.29556;
  unsigned int D.29559;
  int count.84;
  int count.85;
  struct MonoExceptionClause * D.29562;
  long unsigned int D.29565;
  long unsigned int D.29566;
  long unsigned int D.29569;
  unsigned int D.29572;
  struct MonoRegState * D.29575;
  long unsigned int D.29576;
  struct MonoRegState * D.29579;
  int D.29580;
  unsigned int D.29581;
  unsigned int D.29582;
  int D.29585;
  struct MonoDebugOptions * D.29588;
  int D.29589;
  unsigned int D.29592;
  unsigned int D.29597;
  _Bool D.29604;
  long int D.29605;
  long int D.29606;
  int D.29611;
  unsigned int D.29612;
  unsigned int D.29613;
  unsigned int D.29614;
  int D.29615;
  struct MonoInst * D.29618;
  unsigned char D.29621;
  unsigned char D.29622;
  long int D.29623;
  struct MonoInst * D.29624;
  int D.29625;
  int D.29626;
  const unsigned char * D.29627;
  int D.29628;
  struct MonoBasicBlock * D.29629;
  struct MonoInst * D.29630;
  unsigned int D.29634;
  unsigned int D.29635;
  unsigned int D.29638;
  unsigned int D.29641;
  unsigned int D.29644;
  unsigned int D.29647;
  unsigned int D.29654;
  unsigned int D.29656;
  unsigned int D.29657;
  void * D.29658;
  struct MonoBasicBlock * D.29659;
  struct MonoBasicBlock * * D.29660;
  int dfn.86;
  int D.29662;
  unsigned int D.29663;
  unsigned int D.29666;
  unsigned int D.29667;
  unsigned int D.29668;
  unsigned int D.29671;
  int D.29676;
  struct MonoInst * D.29677;
  struct MonoBasicBlock * * D.29678;
  struct MonoBasicBlock * D.29679;
  short int D.29680;
  unsigned int D.29683;
  unsigned int D.29687;
  unsigned int D.29688;
  unsigned int D.29697;
  unsigned int D.29698;
  long unsigned int D.29701;
  long unsigned int D.29710;
  long unsigned int D.29711;
  unsigned int D.29722;
  unsigned int D.29723;
  unsigned int D.29726;
  void * D.29735;
  unsigned int D.29747;
  struct MonoInst * D.29750;
  long unsigned int D.29753;
  _Bool D.29754;
  long int D.29755;
  long int D.29756;
  _Bool D.29759;
  long int D.29760;
  long int D.29761;
  void * D.29764;
  long int D.29765;
  long unsigned int D.29766;
  int D.29767;
  long long int D.29768;
  long long unsigned int D.29769;
  long long unsigned int D.29770;
  unsigned int D.29773;
  unsigned int D.29778;
  unsigned int D.29779;
  void * D.29786;
  long int D.29787;
  unsigned int D.29788;
  unsigned int D.29789;
  regmask_t * D.29792;
  int need_local_opts.87;
  struct MonoInst * D.29807;
  short unsigned int D.29810;
  short unsigned int D.29811;
  short unsigned int D.29813;
  short unsigned int D.29815;
  struct MonoBasicBlock * * D.29816;
  struct MonoBasicBlock * * D.29817;
  struct MonoBasicBlock * D.29818;
  struct MonoBasicBlock * D.29821;
  struct MonoInst * D.29831;
  struct MonoInst * D.29833;
  unsigned char D.29834;
  struct MonoBasicBlock * D.29835;
  struct MonoBasicBlock * D.29837;
  unsigned int D.29838;
  unsigned int D.29839;
  short unsigned int D.29840;
  int D.29845;
  unsigned int D.29848;
  struct MonoJitInfo * D.29855;
  unsigned char * D.29860;
  unsigned int D.29861;
  int D.29862;
  char * D.29863;
  struct MonoDomain * D.29866;
  union mono_mutex_t * D.29867;
  _Bool D.29870;
  long int D.29871;
  long int D.29872;
  struct MonoJitInfo * D.29875;
  long unsigned int D.29876;
  struct MonoJitDynamicMethodInfo * D.29879;
  _Bool D.29882;
  long int D.29883;
  long int D.29884;
  struct MonoPerfCounters * mono_perfcounters.88;
  unsigned int D.29888;
  unsigned int D.29889;
  unsigned int D.29890;
  unsigned int D.29891;
  int D.29892;
  unsigned int D.29893;
  unsigned int D.29894;
  int D.29895;
  int D.29896;
  int D.29899;
  char * D.29902;
  const char * D.29903;
  const char * D.29904;
  gchar * D.29905;
  int D.29906;
  unsigned int D.29907;
  unsigned int D.29908;
  int D.29909;
  char * D.29914;
  gchar * D.29915;
  int D.29916;
  unsigned int D.29917;
  unsigned int D.29918;
  int D.29919;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  struct MonoError err;
  guint8 * ip;
  struct MonoCompile * cfg;
  int dfn;
  int i;
  int code_size_ratio;
  gboolean deadce_has_run;
  gboolean try_generic_shared;
  gboolean try_llvm;
  struct MonoMethod * method_to_compile;
  struct MonoMethod * method_to_register;
  gboolean method_is_gshared;
  gboolean run_cctors;
  gboolean compile_aot;
  gboolean full_aot;
  void restart_compile = <<< error >>>;

  try
    {
      deadce_has_run = 0;
      try_llvm = 0;
      method_is_gshared = 0;
      D.29332 = flags & 1;
      D.29333 = D.29332 != 0;
      run_cctors = (gboolean) D.29333;
      D.29334 = flags & 2;
      D.29335 = D.29334 != 0;
      compile_aot = (gboolean) D.29335;
      D.29336 = flags & 4;
      D.29337 = D.29336 != 0;
      full_aot = (gboolean) D.29337;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.29338 = mono_profiler_get_events ();
      D.29339 = D.29338 & 16;
      if (D.29339 != 0) goto <D.29340>; else goto <D.29341>;
      <D.29340>:
      mono_profiler_method_jit (method);
      <D.29341>:
      if (0 != 0) goto <D.29342>; else goto <D.29343>;
      <D.29342>:
      <D.29343>:
      if (compile_aot != 0) goto <D.29344>; else goto <D.29345>;
      <D.29344>:
      D.29350 = method->klass;
      D.29351 = mono_class_generic_sharing_enabled (D.29350);
      if (D.29351 != 0) goto <D.29352>; else goto <D.29347>;
      <D.29352>:
      D.29353 = opts & 33554432;
      if (D.29353 != 0) goto <D.29354>; else goto <D.29347>;
      <D.29354>:
      D.29355 = BIT_FIELD_REF <*method, 64, 256>;
      D.29356 = D.29355 & 4503599627370496;
      if (D.29356 != 0) goto <D.29348>; else goto <D.29357>;
      <D.29357>:
      D.29350 = method->klass;
      D.29358 = D.29350->generic_container;
      if (D.29358 != 0B) goto <D.29348>; else goto <D.29359>;
      <D.29359>:
      D.29350 = method->klass;
      D.29360 = D.29350->generic_class;
      if (D.29360 == 0B) goto <D.29361>; else goto <D.29347>;
      <D.29361>:
      D.29362 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.29362 != 0) goto <D.29348>; else goto <D.29347>;
      <D.29348>:
      iftmp.77 = 1;
      goto <D.29349>;
      <D.29347>:
      iftmp.77 = 0;
      <D.29349>:
      try_generic_shared = iftmp.77;
      goto <D.29363>;
      <D.29345>:
      D.29350 = method->klass;
      D.29367 = mono_class_generic_sharing_enabled (D.29350);
      if (D.29367 != 0) goto <D.29368>; else goto <D.29365>;
      <D.29368>:
      D.29353 = opts & 33554432;
      if (D.29353 != 0) goto <D.29369>; else goto <D.29365>;
      <D.29369>:
      D.29370 = mono_method_is_generic_sharable (method, 0);
      if (D.29370 != 0) goto <D.29371>; else goto <D.29365>;
      <D.29371>:
      iftmp.78 = 1;
      goto <D.29366>;
      <D.29365>:
      iftmp.78 = 0;
      <D.29366>:
      try_generic_shared = iftmp.78;
      <D.29363>:
      D.29353 = opts & 33554432;
      if (D.29353 != 0) goto <D.29372>; else goto <D.29373>;
      <D.29372>:
      if (try_generic_shared != 0) goto <D.29374>; else goto <D.29375>;
      <D.29374>:
      D.29376 = mono_stats.generics_sharable_methods;
      D.29377 = D.29376 + 1;
      mono_stats.generics_sharable_methods = D.29377;
      goto <D.29378>;
      <D.29375>:
      D.29379 = mono_method_is_generic_impl (method);
      if (D.29379 != 0) goto <D.29380>; else goto <D.29381>;
      <D.29380>:
      D.29382 = mono_stats.generics_unsharable_methods;
      D.29383 = D.29382 + 1;
      mono_stats.generics_unsharable_methods = D.29383;
      <D.29381>:
      <D.29378>:
      <D.29373>:
      D.29384 = mini_is_gsharedvt_sharable_method (method);
      if (D.29384 != 0) goto <D.29385>; else goto <D.29386>;
      <D.29385>:
      D.29387 = mono_debug_count ();
      if (D.29387 == 0) goto <D.29388>; else goto <D.29389>;
      <D.29388>:
      try_generic_shared = 0;
      <D.29389>:
      if (compile_aot != 0) goto <D.29390>; else goto <D.29391>;
      <D.29390>:
      try_generic_shared = 0;
      <D.29391>:
      <D.29386>:
      D.29394 = is_gsharedvt_method (method);
      if (D.29394 != 0) goto <D.29392>; else goto <D.29395>;
      <D.29395>:
      if (compile_aot != 0) goto <D.29396>; else goto <D.29393>;
      <D.29396>:
      D.29397 = is_open_method (method);
      if (D.29397 != 0) goto <D.29392>; else goto <D.29393>;
      <D.29392>:
      method_is_gshared = 1;
      D.29398 = compile_aot == 0;
      D.29399 = (long int) D.29398;
      D.29400 = __builtin_expect (D.29399, 0);
      if (D.29400 != 0) goto <D.29401>; else goto <D.29402>;
      <D.29401>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.29402>:
      try_generic_shared = 1;
      <D.29393>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.29403>; else goto <D.29404>;
      <D.29403>:
      method_to_compile = method;
      goto <D.29405>;
      <D.29404>:
      if (try_generic_shared != 0) goto <D.29406>; else goto <D.29407>;
      <D.29406>:
      method_to_compile = mini_get_shared_method (method);
      D.29408 = method_to_compile == 0B;
      D.29409 = (long int) D.29408;
      D.29410 = __builtin_expect (D.29409, 0);
      if (D.29410 != 0) goto <D.29411>; else goto <D.29412>;
      <D.29411>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4898, "method_to_compile");
      <D.29412>:
      goto <D.29413>;
      <D.29407>:
      method_to_compile = method;
      <D.29413>:
      <D.29405>:
      cfg = monoeg_malloc0 (1128);
      cfg->method = method_to_compile;
      D.29414 = cfg->method;
      D.29415 = mono_method_get_header (D.29414);
      cfg->header = D.29415;
      D.29416 = mono_mempool_new ();
      cfg->mempool = D.29416;
      cfg->opt = opts;
      D.29417 = mono_profiler_get_events ();
      cfg->prof_options = D.29417;
      D.29418 = (unsigned char) run_cctors;
      D.29419 = (<unnamed-unsigned:1>) D.29418;
      cfg->run_cctors = D.29419;
      cfg->domain = domain;
      mini_verbose.79 = mini_verbose;
      mini_verbose.80 = (unsigned int) mini_verbose.79;
      cfg->verbose_level = mini_verbose.80;
      D.29422 = (unsigned char) compile_aot;
      D.29423 = (<unnamed-unsigned:1>) D.29422;
      cfg->compile_aot = D.29423;
      D.29424 = (unsigned char) full_aot;
      D.29425 = (<unnamed-unsigned:1>) D.29424;
      cfg->full_aot = D.29425;
      D.29426 = method->skip_visibility;
      cfg->skip_visibility = D.29426;
      cfg->orig_method = method;
      D.29427 = debug_options.gen_seq_points;
      D.29428 = (unsigned char) D.29427;
      D.29429 = (<unnamed-unsigned:1>) D.29428;
      cfg->gen_seq_points = D.29429;
      D.29430 = debug_options.explicit_null_checks;
      D.29431 = (unsigned char) D.29430;
      D.29432 = (<unnamed-unsigned:1>) D.29431;
      cfg->explicit_null_checks = D.29432;
      D.29433 = debug_options.soft_breakpoints;
      D.29434 = (unsigned char) D.29433;
      D.29435 = (<unnamed-unsigned:1>) D.29434;
      cfg->soft_breakpoints = D.29435;
      if (try_generic_shared != 0) goto <D.29436>; else goto <D.29437>;
      <D.29436>:
      D.29438 = &cfg->gsctx;
      cfg->generic_sharing_context = D.29438;
      <D.29437>:
      D.29439 = (unsigned char) try_llvm;
      D.29440 = (<unnamed-unsigned:1>) D.29439;
      cfg->compile_llvm = D.29440;
      D.29441 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.29441;
      D.29442 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.29443 = D.29442 & 288230376151711744;
      if (D.29443 != 0) goto <D.29444>; else goto <D.29445>;
      <D.29444>:
      D.29446 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.29446;
      <D.29445>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29450 = D.29449 & 33554432;
      if (D.29450 != 0) goto <D.29451>; else goto <D.29452>;
      <D.29451>:
      if (try_generic_shared == 0) goto <D.29453>; else goto <D.29454>;
      <D.29453>:
      D.29355 = BIT_FIELD_REF <*method, 64, 256>;
      D.29356 = D.29355 & 4503599627370496;
      if (D.29356 != 0) goto <D.29447>; else goto <D.29455>;
      <D.29455>:
      D.29350 = method->klass;
      D.29358 = D.29350->generic_container;
      if (D.29358 != 0B) goto <D.29447>; else goto <D.29456>;
      <D.29456>:
      if (method_is_gshared != 0) goto <D.29447>; else goto <D.29448>;
      <D.29447>:
      cfg->exception_type = 11;
      D.29457 = cfg;
      return D.29457;
      <D.29448>:
      <D.29454>:
      <D.29452>:
      D.29460 = cfg->generic_sharing_context;
      if (D.29460 != 0B) goto <D.29461>; else goto <D.29462>;
      <D.29461>:
      D.29463 = mini_is_gsharedvt_sharable_method (method);
      if (D.29463 != 0) goto <D.29458>; else goto <D.29464>;
      <D.29464>:
      if (method_is_gshared != 0) goto <D.29458>; else goto <D.29459>;
      <D.29458>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.29465>; else goto <D.29466>;
        <D.29465>:
        D.29355 = BIT_FIELD_REF <*method, 64, 256>;
        D.29467 = D.29355 & 2251799813685248;
        D.29468 = D.29467 == 0;
        D.29469 = (long int) D.29468;
        D.29470 = __builtin_expect (D.29469, 0);
        if (D.29470 != 0) goto <D.29471>; else goto <D.29472>;
        <D.29471>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.29472>:
        inflated = method;
        context = &inflated->context;
        D.29398 = compile_aot == 0;
        D.29399 = (long int) D.29398;
        D.29400 = __builtin_expect (D.29399, 0);
        if (D.29400 != 0) goto <D.29473>; else goto <D.29474>;
        <D.29473>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.29474>:
        goto <D.29475>;
        <D.29466>:
        D.29476 = BIT_FIELD_REF <*method_to_compile, 64, 256>;
        D.29477 = D.29476 & 2251799813685248;
        D.29478 = D.29477 == 0;
        D.29479 = (long int) D.29478;
        D.29480 = __builtin_expect (D.29479, 0);
        if (D.29480 != 0) goto <D.29481>; else goto <D.29482>;
        <D.29481>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.29482>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.29475>:
        D.29438 = &cfg->gsctx;
        mini_init_gsctx (context, D.29438);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.29459>:
      <D.29462>:
      D.29460 = cfg->generic_sharing_context;
      if (D.29460 != 0B) goto <D.29483>; else goto <D.29484>;
      <D.29483>:
      method_to_register = method_to_compile;
      goto <D.29485>;
      <D.29484>:
      D.29486 = method != method_to_compile;
      D.29487 = (long int) D.29486;
      D.29488 = __builtin_expect (D.29487, 0);
      if (D.29488 != 0) goto <D.29489>; else goto <D.29490>;
      <D.29489>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.29490>:
      method_to_register = method;
      <D.29485>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.29414 = cfg->method;
      sig = mono_method_signature_checked (D.29414, &err);
      if (sig == 0B) goto <D.29491>; else goto <D.29492>;
      <D.29491>:
      cfg->exception_type = 7;
      D.29493 = mono_error_get_message (&err);
      D.29494 = monoeg_strdup (D.29493);
      cfg->exception_message = D.29494;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.29495>; else goto <D.29496>;
      <D.29495>:
      <D.29496>:
      D.29457 = cfg;
      return D.29457;
      <D.29492>:
      header = cfg->header;
      if (header == 0B) goto <D.29497>; else goto <D.29498>;
      <D.29497>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.29499>; else goto <D.29500>;
        <D.29499>:
        D.29501 = error->exception_type;
        D.29502 = (unsigned int) D.29501;
        cfg->exception_type = D.29502;
        goto <D.29503>;
        <D.29500>:
        cfg->exception_type = 3;
        D.29414 = cfg->method;
        D.29504 = D.29414->name;
        D.29505 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.29504);
        cfg->exception_message = D.29505;
        <D.29503>:
        if (0 != 0) goto <D.29506>; else goto <D.29507>;
        <D.29506>:
        <D.29507>:
        D.29457 = cfg;
        return D.29457;
      }
      <D.29498>:
      D.29508 = debug_options.mdb_optimizations;
      if (D.29508 != 0) goto <D.29509>; else goto <D.29510>;
      <D.29509>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->disable_initlocals_opt = 1;
      cfg->extend_live_ranges = 1;
      cfg->disable_vreg_to_lvreg = 1;
      cfg->disable_deadce_vars = 1;
      D.29511 = cfg->opt;
      D.29512 = D.29511 & 4294967231;
      cfg->opt = D.29512;
      D.29511 = cfg->opt;
      D.29513 = D.29511 & 4294967291;
      cfg->opt = D.29513;
      D.29511 = cfg->opt;
      D.29514 = D.29511 & 4294967263;
      cfg->opt = D.29514;
      D.29511 = cfg->opt;
      D.29515 = D.29511 & 4294967279;
      cfg->opt = D.29515;
      cfg->disable_out_of_line_bblocks = 1;
      <D.29510>:
      mono_using_xdebug.81 = mono_using_xdebug;
      if (mono_using_xdebug.81 != 0) goto <D.29517>; else goto <D.29518>;
      <D.29517>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.29518>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.29519>; else goto <D.29520>;
      <D.29519>:
      D.29511 = cfg->opt;
      D.29521 = D.29511 | 262144;
      cfg->opt = D.29521;
      <D.29520>:
      D.29522 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.29522 != 0B) goto <D.29523>; else goto <D.29524>;
      <D.29523>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.29528 = __builtin_strchr (name, 46);
        if (D.29528 > name) goto <D.29525>; else goto <D.29529>;
        <D.29529>:
        D.29530 = __builtin_strchr (name, 58);
        if (D.29530 != 0B) goto <D.29525>; else goto <D.29526>;
        <D.29525>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.29414 = cfg->method;
          D.29531 = mono_method_desc_full_match (desc, D.29414);
          if (D.29531 != 0) goto <D.29532>; else goto <D.29533>;
          <D.29532>:
          cfg->verbose_level = 4;
          <D.29533>:
          mono_method_desc_free (desc);
        }
        goto <D.29527>;
        <D.29526>:
        D.29414 = cfg->method;
        D.29504 = D.29414->name;
        D.29534 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.29535 = strcmp (D.29504, D.29534);
        if (D.29535 == 0) goto <D.29536>; else goto <D.29537>;
        <D.29536>:
        cfg->verbose_level = 4;
        <D.29537>:
        <D.29527>:
      }
      <D.29524>:
      ip = header->code;
      D.29538 = cfg->mempool;
      D.29539 = header->max_stack;
      D.29540 = (unsigned int) D.29539;
      D.29541 = D.29540 * 16;
      D.29542 = mono_mempool_alloc0 (D.29538, D.29541);
      cfg->intvars = D.29542;
      D.29543 = cfg->verbose_level;
      if (D.29543 != 0) goto <D.29544>; else goto <D.29545>;
      <D.29544>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.29547 = cfg->gsharedvt;
        if (D.29547 != 0) goto <D.29548>; else goto <D.29549>;
        <D.29548>:
        iftmp.82 = "gsharedvt ";
        goto <D.29550>;
        <D.29549>:
        iftmp.82 = "";
        <D.29550>:
        D.29460 = cfg->generic_sharing_context;
        if (D.29460 != 0B) goto <D.29554>; else goto <D.29552>;
        <D.29554>:
        D.29547 = cfg->gsharedvt;
        if (D.29547 == 0) goto <D.29555>; else goto <D.29552>;
        <D.29555>:
        iftmp.83 = "gshared ";
        goto <D.29553>;
        <D.29552>:
        iftmp.83 = "";
        <D.29553>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.82, iftmp.83, method_name);
        monoeg_g_free (method_name);
      }
      <D.29545>:
      D.29511 = cfg->opt;
      D.29556 = D.29511 & 786432;
      if (D.29556 != 0) goto <D.29557>; else goto <D.29558>;
      <D.29557>:
      D.29511 = cfg->opt;
      D.29559 = D.29511 | 2097152;
      cfg->opt = D.29559;
      <D.29558>:
      {
        static int count = 0;

        count.84 = count;
        count.85 = count.84 + 1;
        count = count.85;
      }
      D.29562 = header->clauses;
      if (D.29562 != 0B) goto <D.29563>; else goto <D.29564>;
      <D.29563>:
      cfg->globalra = 0;
      <D.29564>:
      D.29414 = cfg->method;
      D.29565 = BIT_FIELD_REF <*D.29414, 64, 256>;
      D.29566 = D.29565 & 4467570830351532032;
      if (D.29566 == 720575940379279360) goto <D.29567>; else goto <D.29568>;
      <D.29567>:
      cfg->globalra = 0;
      <D.29568>:
      D.29414 = cfg->method;
      D.29565 = BIT_FIELD_REF <*D.29414, 64, 256>;
      D.29569 = D.29565 & 36028797018963968;
      if (D.29569 != 0) goto <D.29570>; else goto <D.29571>;
      <D.29570>:
      cfg->globalra = 0;
      <D.29571>:
      D.29572 = header->code_size;
      if (D.29572 > 5000) goto <D.29573>; else goto <D.29574>;
      <D.29573>:
      cfg->globalra = 0;
      <D.29574>:
      D.29575 = mono_regstate_new ();
      cfg->rs = D.29575;
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29576 = D.29449 & 524288;
      if (D.29576 != 0) goto <D.29577>; else goto <D.29578>;
      <D.29577>:
      D.29579 = cfg->rs;
      D.29579->next_vreg = 32;
      <D.29578>:
      D.29579 = cfg->rs;
      D.29580 = D.29579->next_vreg;
      D.29581 = (unsigned int) D.29580;
      cfg->next_vreg = D.29581;
      D.29511 = cfg->opt;
      D.29582 = D.29511 & 2097152;
      if (D.29582 != 0) goto <D.29583>; else goto <D.29584>;
      <D.29583>:
      cfg->enable_extended_bblocks = 0;
      <D.29584>:
      D.29414 = cfg->method;
      D.29585 = mono_compile_is_broken (cfg, D.29414, 1);
      if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
      <D.29586>:
      D.29588 = mini_get_debug_options ();
      D.29589 = D.29588->break_on_unverified;
      if (D.29589 != 0) goto <D.29590>; else goto <D.29591>;
      <D.29590>:
      raise (5);
      <D.29591>:
      D.29457 = cfg;
      return D.29457;
      <D.29587>:
      mono_compile_create_vars (cfg);
      D.29511 = cfg->opt;
      D.29592 = D.29511 & 4294443007;
      cfg->opt = D.29592;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.29593>; else goto <D.29594>;
      <D.29593>:
      if (try_generic_shared != 0) goto <D.29595>; else goto <D.29596>;
      <D.29595>:
      D.29597 = cfg->exception_type;
      if (D.29597 == 11) goto <D.29598>; else goto <D.29599>;
      <D.29598>:
      if (compile_aot != 0) goto <D.29600>; else goto <D.29601>;
      <D.29600>:
      if (0 != 0) goto <D.29602>; else goto <D.29603>;
      <D.29602>:
      <D.29603>:
      D.29457 = cfg;
      return D.29457;
      <D.29601>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.29599>:
      <D.29596>:
      D.29597 = cfg->exception_type;
      D.29604 = D.29597 == 11;
      D.29605 = (long int) D.29604;
      D.29606 = __builtin_expect (D.29605, 0);
      if (D.29606 != 0) goto <D.29607>; else goto <D.29608>;
      <D.29607>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.29608>:
      if (0 != 0) goto <D.29609>; else goto <D.29610>;
      <D.29609>:
      <D.29610>:
      D.29457 = cfg;
      return D.29457;
      <D.29594>:
      D.29611 = cfg->stat_basic_blocks;
      D.29612 = (unsigned int) D.29611;
      D.29613 = cfg->num_bblocks;
      D.29614 = D.29612 + D.29613;
      D.29615 = (int) D.29614;
      cfg->stat_basic_blocks = D.29615;
      if (0 != 0) goto <D.29616>; else goto <D.29617>;
      <D.29616>:
      {
        struct MonoInst * ins;

        D.29511 = cfg->opt;
        D.29559 = D.29511 | 2097152;
        cfg->opt = D.29559;
        D.29618 = cfg->ret;
        if (D.29618 != 0B) goto <D.29619>; else goto <D.29620>;
        <D.29619>:
        D.29618 = cfg->ret;
        D.29618 = cfg->ret;
        D.29621 = D.29618->flags;
        D.29622 = D.29621 & 251;
        D.29618->flags = D.29622;
        D.29538 = cfg->mempool;
        ins = mono_mempool_alloc (D.29538, 80);
        ins->data.op[1].const_val = 0;
        D.29623 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29623;
        ins->prev = 0B;
        D.29624 = ins->prev;
        ins->next = D.29624;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29625 = ins->sreg3;
        ins->sreg2 = D.29625;
        D.29626 = ins->sreg2;
        ins->sreg1 = D.29626;
        D.29627 = cfg->ip;
        ins->cil_code = D.29627;
        D.29618 = cfg->ret;
        D.29628 = D.29618->dreg;
        ins->sreg1 = D.29628;
        D.29629 = cfg->bb_exit;
        D.29630 = D.29629->last_ins;
        if (D.29630 != 0B) goto <D.29631>; else goto <D.29632>;
        <D.29631>:
        D.29629 = cfg->bb_exit;
        D.29630 = D.29629->last_ins;
        D.29630->next = ins;
        D.29629 = cfg->bb_exit;
        D.29630 = D.29629->last_ins;
        ins->prev = D.29630;
        D.29629 = cfg->bb_exit;
        D.29629->last_ins = ins;
        goto <D.29633>;
        <D.29632>:
        D.29629 = cfg->bb_exit;
        D.29629 = cfg->bb_exit;
        D.29629->last_ins = ins;
        D.29630 = D.29629->last_ins;
        D.29629->code = D.29630;
        <D.29633>:
        <D.29620>:
        D.29511 = cfg->opt;
        D.29634 = D.29511 & 4294967167;
        cfg->opt = D.29634;
        D.29511 = cfg->opt;
        D.29635 = D.29511 & 4294967293;
        cfg->opt = D.29635;
      }
      <D.29617>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.29636>; else goto <D.29637>;
      <D.29636>:
      mono_decompose_long_opts (cfg);
      <D.29637>:
      D.29511 = cfg->opt;
      D.29638 = D.29511 & 48;
      if (D.29638 != 0) goto <D.29639>; else goto <D.29640>;
      <D.29639>:
      mono_local_cprop (cfg);
      <D.29640>:
      D.29511 = cfg->opt;
      D.29641 = D.29511 & 2;
      if (D.29641 != 0) goto <D.29642>; else goto <D.29643>;
      <D.29642>:
      mono_optimize_branches (cfg);
      <D.29643>:
      mono_handle_global_vregs (cfg);
      D.29511 = cfg->opt;
      D.29644 = D.29511 & 64;
      if (D.29644 != 0) goto <D.29645>; else goto <D.29646>;
      <D.29645>:
      mono_local_deadce (cfg);
      <D.29646>:
      D.29511 = cfg->opt;
      D.29647 = D.29511 & 268435456;
      if (D.29647 != 0) goto <D.29648>; else goto <D.29649>;
      <D.29648>:
      mono_local_alias_analysis (cfg);
      <D.29649>:
      if (1 != 0) goto <D.29650>; else goto <D.29651>;
      <D.29650>:
      mono_if_conversion (cfg);
      <D.29651>:
      D.29511 = cfg->opt;
      D.29654 = D.29511 & 524288;
      if (D.29654 != 0) goto <D.29652>; else goto <D.29655>;
      <D.29655>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29576 = D.29449 & 524288;
      if (D.29576 != 0) goto <D.29652>; else goto <D.29653>;
      <D.29652>:
      mono_remove_critical_edges (cfg);
      <D.29653>:
      D.29538 = cfg->mempool;
      D.29613 = cfg->num_bblocks;
      D.29656 = D.29613 + 1;
      D.29657 = D.29656 * 8;
      D.29658 = mono_mempool_alloc (D.29538, D.29657);
      cfg->bblocks = D.29658;
      D.29613 = cfg->num_bblocks;
      cfg->max_block_num = D.29613;
      dfn = 0;
      D.29659 = cfg->bb_entry;
      D.29660 = cfg->bblocks;
      df_visit (D.29659, &dfn, D.29660);
      D.29613 = cfg->num_bblocks;
      dfn.86 = dfn;
      D.29662 = dfn.86 + 1;
      D.29663 = (unsigned int) D.29662;
      if (D.29613 != D.29663) goto <D.29664>; else goto <D.29665>;
      <D.29664>:
      {
        struct MonoBasicBlock * bb;

        dfn.86 = dfn;
        D.29662 = dfn.86 + 1;
        D.29663 = (unsigned int) D.29662;
        cfg->num_bblocks = D.29663;
        bb = cfg->bb_entry;
        goto <D.26533>;
        <D.26532>:
        D.29666 = bb->flags;
        D.29667 = D.29666 & 4294967294;
        bb->flags = D.29667;
        bb = bb->next_bb;
        <D.26533>:
        if (bb != 0B) goto <D.26532>; else goto <D.26534>;
        <D.26534>:
        D.29659 = cfg->bb_entry;
        compute_reachable (D.29659);
        bb = cfg->bb_entry;
        goto <D.26536>;
        <D.26535>:
        D.29666 = bb->flags;
        D.29668 = D.29666 & 16;
        if (D.29668 != 0) goto <D.29669>; else goto <D.29670>;
        <D.29669>:
        compute_reachable (bb);
        <D.29670>:
        bb = bb->next_bb;
        <D.26536>:
        if (bb != 0B) goto <D.26535>; else goto <D.26537>;
        <D.26537>:
        bb = cfg->bb_entry;
        goto <D.26542>;
        <D.26541>:
        D.29666 = bb->flags;
        D.29671 = D.29666 & 1;
        if (D.29671 == 0) goto <D.29672>; else goto <D.29673>;
        <D.29672>:
        D.29543 = cfg->verbose_level;
        if (D.29543 > 1) goto <D.29674>; else goto <D.29675>;
        <D.29674>:
        D.29676 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.29676);
        <D.29675>:
        bb->last_ins = 0B;
        D.29677 = bb->last_ins;
        bb->code = D.29677;
        goto <D.26539>;
        <D.26538>:
        D.29678 = bb->out_bb;
        D.29679 = *D.29678;
        mono_unlink_bblock (cfg, bb, D.29679);
        <D.26539>:
        D.29680 = bb->out_count;
        if (D.29680 != 0) goto <D.26538>; else goto <D.26540>;
        <D.26540>:
        <D.29673>:
        bb = bb->next_bb;
        <D.26542>:
        if (bb != 0B) goto <D.26541>; else goto <D.26543>;
        <D.26543>:
        bb = cfg->bb_entry;
        goto <D.26545>;
        <D.26544>:
        D.29666 = bb->flags;
        D.29667 = D.29666 & 4294967294;
        bb->flags = D.29667;
        bb = bb->next_bb;
        <D.26545>:
        if (bb != 0B) goto <D.26544>; else goto <D.26546>;
        <D.26546>:
      }
      <D.29665>:
      D.29683 = cfg->num_varinfo;
      if (D.29683 > 2000) goto <D.29681>; else goto <D.29684>;
      <D.29684>:
      D.29613 = cfg->num_bblocks;
      if (D.29613 > 1000) goto <D.29681>; else goto <D.29682>;
      <D.29681>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29450 = D.29449 & 33554432;
      if (D.29450 == 0) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      D.29511 = cfg->opt;
      D.29687 = D.29511 & 4294967119;
      cfg->opt = D.29687;
      cfg->disable_ssa = 1;
      <D.29686>:
      <D.29682>:
      D.29511 = cfg->opt;
      D.29688 = D.29511 & 8192;
      if (D.29688 != 0) goto <D.29689>; else goto <D.29690>;
      <D.29689>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.29690>:
      if (parts == 1) goto <D.29691>; else goto <D.29692>;
      <D.29691>:
      if (0 != 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      <D.29694>:
      D.29457 = cfg;
      return D.29457;
      <D.29692>:
      D.29511 = cfg->opt;
      D.29582 = D.29511 & 2097152;
      if (D.29582 != 0) goto <D.29695>; else goto <D.29696>;
      <D.29695>:
      D.29697 = cfg->comp_done;
      D.29698 = D.29697 & 32;
      if (D.29698 == 0) goto <D.29699>; else goto <D.29700>;
      <D.29699>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29701 = D.29449 & 1073741824;
      if (D.29701 == 0) goto <D.29702>; else goto <D.29703>;
      <D.29702>:
      mono_ssa_compute (cfg);
      D.29543 = cfg->verbose_level;
      if (D.29543 > 1) goto <D.29704>; else goto <D.29705>;
      <D.29704>:
      print_dfn (cfg);
      <D.29705>:
      <D.29703>:
      <D.29700>:
      <D.29696>:
      if (parts == 2) goto <D.29706>; else goto <D.29707>;
      <D.29706>:
      if (0 != 0) goto <D.29708>; else goto <D.29709>;
      <D.29708>:
      <D.29709>:
      D.29457 = cfg;
      return D.29457;
      <D.29707>:
      D.29710 = BIT_FIELD_REF <*cfg, 64, 5312>;
      D.29711 = D.29710 & 206158430208;
      if (D.29711 != 0) goto <D.29712>; else goto <D.29713>;
      <D.29712>:
      D.29697 = cfg->comp_done;
      D.29698 = D.29697 & 32;
      if (D.29698 != 0) goto <D.29714>; else goto <D.29715>;
      <D.29714>:
      mono_ssa_cprop (cfg);
      <D.29715>:
      <D.29713>:
      D.29697 = cfg->comp_done;
      D.29698 = D.29697 & 32;
      if (D.29698 != 0) goto <D.29716>; else goto <D.29717>;
      <D.29716>:
      D.29511 = cfg->opt;
      D.29654 = D.29511 & 524288;
      if (D.29654 != 0) goto <D.29718>; else goto <D.29719>;
      <D.29718>:
      mono_perform_ssapre (cfg);
      <D.29719>:
      D.29511 = cfg->opt;
      D.29644 = D.29511 & 64;
      if (D.29644 != 0) goto <D.29720>; else goto <D.29721>;
      <D.29720>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.29721>:
      D.29722 = cfg->flags;
      D.29723 = D.29722 & 132;
      if (D.29723 != 0) goto <D.29724>; else goto <D.29725>;
      <D.29724>:
      D.29511 = cfg->opt;
      D.29726 = D.29511 & 262144;
      if (D.29726 != 0) goto <D.29727>; else goto <D.29728>;
      <D.29727>:
      mono_perform_abc_removal (cfg);
      <D.29728>:
      <D.29725>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.29511 = cfg->opt;
      D.29644 = D.29511 & 64;
      if (D.29644 != 0) goto <D.29729>; else goto <D.29730>;
      <D.29729>:
      mono_local_deadce (cfg);
      <D.29730>:
      D.29511 = cfg->opt;
      D.29641 = D.29511 & 2;
      if (D.29641 != 0) goto <D.29731>; else goto <D.29732>;
      <D.29731>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29576 = D.29449 & 524288;
        if (D.29576 != 0) goto <D.29733>; else goto <D.29734>;
        <D.29733>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.26549>;
        <D.26548>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.26549>:
        if (bb != 0B) goto <D.26548>; else goto <D.26550>;
        <D.26550>:
        D.29538 = cfg->mempool;
        D.29613 = cfg->num_bblocks;
        D.29656 = D.29613 + 1;
        D.29657 = D.29656 * 8;
        D.29735 = mono_mempool_alloc (D.29538, D.29657);
        cfg->bblocks = D.29735;
        dfn = 0;
        D.29659 = cfg->bb_entry;
        D.29660 = cfg->bblocks;
        df_visit (D.29659, &dfn, D.29660);
        dfn.86 = dfn;
        D.29662 = dfn.86 + 1;
        D.29663 = (unsigned int) D.29662;
        cfg->num_bblocks = D.29663;
        <D.29734>:
      }
      <D.29732>:
      <D.29717>:
      if (0 != 0) goto <D.29736>; else goto <D.29737>;
      <D.29736>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.29511 = cfg->opt;
      D.29726 = D.29511 & 262144;
      if (D.29726 != 0) goto <D.29738>; else goto <D.29739>;
      <D.29738>:
      mono_perform_abc_removal (cfg);
      <D.29739>:
      <D.29737>:
      if (parts == 3) goto <D.29740>; else goto <D.29741>;
      <D.29740>:
      if (0 != 0) goto <D.29742>; else goto <D.29743>;
      <D.29742>:
      <D.29743>:
      D.29457 = cfg;
      return D.29457;
      <D.29741>:
      if (0 != 0) goto <D.29744>; else goto <D.29745>;
      <D.29744>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.29746>;
      <D.29745>:
      mono_decompose_vtype_opts (cfg);
      <D.29746>:
      D.29722 = cfg->flags;
      D.29747 = D.29722 & 256;
      if (D.29747 != 0) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      mono_decompose_array_access_opts (cfg);
      <D.29749>:
      D.29750 = cfg->got_var;
      if (D.29750 != 0B) goto <D.29751>; else goto <D.29752>;
      <D.29751>:
      {
        struct GList * regs;
        int got_reg;

        D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29753 = D.29449 & 4194304;
        D.29754 = D.29753 == 0;
        D.29755 = (long int) D.29754;
        D.29756 = __builtin_expect (D.29755, 0);
        if (D.29756 != 0) goto <D.29757>; else goto <D.29758>;
        <D.29757>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.29758>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29759 = regs == 0B;
        D.29760 = (long int) D.29759;
        D.29761 = __builtin_expect (D.29760, 0);
        if (D.29761 != 0) goto <D.29762>; else goto <D.29763>;
        <D.29762>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5473, "regs");
        <D.29763>:
        D.29764 = regs->data;
        D.29765 = (long int) D.29764;
        got_reg = (int) D.29765;
        monoeg_g_list_free (regs);
        D.29750 = cfg->got_var;
        D.29750->opcode = 366;
        D.29750 = cfg->got_var;
        D.29750->dreg = got_reg;
        D.29766 = cfg->used_int_regs;
        D.29750 = cfg->got_var;
        D.29767 = D.29750->dreg;
        D.29768 = 1 << D.29767;
        D.29769 = (long long unsigned int) D.29768;
        D.29770 = D.29766 | D.29769;
        cfg->used_int_regs = D.29770;
      }
      <D.29752>:
      mono_liveness_handle_exception_clauses (cfg);
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29576 = D.29449 & 524288;
      if (D.29576 != 0) goto <D.29771>; else goto <D.29772>;
      <D.29771>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.26555>;
        <D.26554>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.26555>:
        if (bb != 0B) goto <D.26554>; else goto <D.26556>;
        <D.26556>:
        mono_global_regalloc (cfg);
      }
      <D.29772>:
      D.29511 = cfg->opt;
      D.29773 = D.29511 & 128;
      if (D.29773 != 0) goto <D.29774>; else goto <D.29775>;
      <D.29774>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29576 = D.29449 & 524288;
      if (D.29576 == 0) goto <D.29776>; else goto <D.29777>;
      <D.29776>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.29697 = cfg->comp_done;
        D.29778 = D.29697 & 4294967279;
        cfg->comp_done = D.29778;
        D.29697 = cfg->comp_done;
        D.29779 = D.29697 & 16;
        if (D.29779 == 0) goto <D.29780>; else goto <D.29781>;
        <D.29780>:
        mono_analyze_liveness (cfg);
        <D.29781>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.29782>; else goto <D.29783>;
        <D.29782>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29750 = cfg->got_var;
        if (D.29750 != 0B) goto <D.29784>; else goto <D.29785>;
        <D.29784>:
        l = regs;
        goto <D.26562>;
        <D.26561>:
        D.29786 = l->data;
        D.29787 = (long int) D.29786;
        D.29788 = (unsigned int) D.29787;
        D.29750 = cfg->got_var;
        D.29767 = D.29750->dreg;
        D.29789 = (unsigned int) D.29767;
        if (D.29788 == D.29789) goto <D.29790>; else goto <D.29791>;
        <D.29790>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.26560>;
        <D.29791>:
        l = l->next;
        <D.26562>:
        if (l != 0B) goto <D.26561>; else goto <D.26560>;
        <D.26560>:
        <D.29785>:
        D.29792 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.29792);
        <D.29783>:
      }
      <D.29777>:
      <D.29775>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29576 = D.29449 & 524288;
      if (D.29576 == 0) goto <D.29793>; else goto <D.29794>;
      <D.29793>:
      mono_arch_allocate_vars (cfg);
      D.29597 = cfg->exception_type;
      if (D.29597 != 0) goto <D.29795>; else goto <D.29796>;
      <D.29795>:
      D.29457 = cfg;
      return D.29457;
      <D.29796>:
      <D.29794>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29576 = D.29449 & 524288;
            if (D.29576 == 0) goto <D.29797>; else goto <D.29798>;
            <D.29797>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.87 = need_local_opts;
            if (need_local_opts.87 != 0) goto <D.29799>; else goto <D.29802>;
            <D.29802>:
            D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29450 = D.29449 & 33554432;
            if (D.29450 != 0) goto <D.29799>; else goto <D.29800>;
            <D.29799>:
            mono_local_cprop (cfg);
            D.29511 = cfg->opt;
            D.29644 = D.29511 & 64;
            if (D.29644 != 0) goto <D.29803>; else goto <D.29804>;
            <D.29803>:
            mono_local_deadce (cfg);
            <D.29804>:
            <D.29800>:
            <D.29798>:
            bb = cfg->bb_entry;
            goto <D.26568>;
            <D.26567>:
            D.29807 = bb->last_ins;
            if (D.29807 != 0B) goto <D.29808>; else goto <D.29809>;
            <D.29808>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29811 = D.29810 + 64985;
            if (D.29811 <= 9) goto <D.29805>; else goto <D.29812>;
            <D.29812>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29813 = D.29810 + 64878;
            if (D.29813 <= 9) goto <D.29805>; else goto <D.29814>;
            <D.29814>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29815 = D.29810 + 64888;
            if (D.29815 <= 9) goto <D.29805>; else goto <D.29806>;
            <D.29805>:
            D.29807 = bb->last_ins;
            D.29816 = D.29807->data.op[1].many_blocks;
            D.29817 = D.29816 + 8;
            D.29818 = *D.29817;
            if (D.29818 != 0B) goto <D.29819>; else goto <D.29820>;
            <D.29819>:
            D.29821 = bb->next_bb;
            D.29807 = bb->last_ins;
            D.29816 = D.29807->data.op[1].many_blocks;
            D.29817 = D.29816 + 8;
            D.29818 = *D.29817;
            if (D.29821 != D.29818) goto <D.29822>; else goto <D.29823>;
            <D.29822>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29811 = D.29810 + 64985;
            if (D.29811 <= 9) goto <D.29824>; else goto <D.29828>;
            <D.29828>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29813 = D.29810 + 64878;
            if (D.29813 <= 9) goto <D.29824>; else goto <D.29829>;
            <D.29829>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29815 = D.29810 + 64888;
            if (D.29815 <= 9) goto <D.29824>; else goto <D.29825>;
            <D.29824>:
            D.29807 = bb->last_ins;
            D.29810 = D.29807->opcode;
            D.29813 = D.29810 + 64878;
            if (D.29813 > 9) goto <D.29830>; else goto <D.29825>;
            <D.29830>:
            D.29807 = bb->last_ins;
            D.29831 = D.29807->data.op[0].src;
            if (D.29831 == 0B) goto <D.29826>; else goto <D.29832>;
            <D.29832>:
            D.29807 = bb->last_ins;
            D.29831 = D.29807->data.op[0].src;
            D.29833 = D.29831->data.op[0].src;
            D.29834 = D.29833->type;
            if (D.29834 != 4) goto <D.29826>; else goto <D.29825>;
            <D.29826>:
            D.29821 = bb->next_bb;
            D.29807 = bb->last_ins;
            D.29816 = D.29807->data.op[1].many_blocks;
            D.29835 = *D.29816;
            if (D.29821 == D.29835) goto <D.29836>; else goto <D.29825>;
            <D.29836>:
            {
              struct MonoBasicBlock * tmp;

              D.29807 = bb->last_ins;
              D.29816 = D.29807->data.op[1].many_blocks;
              tmp = *D.29816;
              D.29807 = bb->last_ins;
              D.29816 = D.29807->data.op[1].many_blocks;
              D.29807 = bb->last_ins;
              D.29816 = D.29807->data.op[1].many_blocks;
              D.29837 = MEM[(struct MonoBasicBlock * *)D.29816 + 8B];
              *D.29816 = D.29837;
              D.29807 = bb->last_ins;
              D.29816 = D.29807->data.op[1].many_blocks;
              D.29817 = D.29816 + 8;
              *D.29817 = tmp;
              D.29807 = bb->last_ins;
              D.29807 = bb->last_ins;
              D.29810 = D.29807->opcode;
              D.29838 = (unsigned int) D.29810;
              D.29839 = mono_reverse_branch_op (D.29838);
              D.29840 = (short unsigned int) D.29839;
              D.29807->opcode = D.29840;
            }
            goto <D.29827>;
            <D.29825>:
            {
              struct MonoInst * inst;

              D.29538 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.29538, 80);
              inst->opcode = 442;
              D.29807 = bb->last_ins;
              D.29816 = D.29807->data.op[1].many_blocks;
              D.29837 = MEM[(struct MonoBasicBlock * *)D.29816 + 8B];
              inst->data.op[0].target_block = D.29837;
              mono_bblock_add_inst (bb, inst);
            }
            <D.29827>:
            <D.29823>:
            <D.29820>:
            <D.29806>:
            <D.29809>:
            bb = bb->next_bb;
            <D.26568>:
            if (bb != 0B) goto <D.26567>; else goto <D.26569>;
            <D.26569>:
            D.29543 = cfg->verbose_level;
            if (D.29543 > 3) goto <D.29841>; else goto <D.29842>;
            <D.29841>:
            D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29576 = D.29449 & 524288;
            if (D.29576 == 0) goto <D.29843>; else goto <D.29844>;
            <D.29843>:
            bb = cfg->bb_entry;
            goto <D.26576>;
            <D.26575>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.29845 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.29845);
              if (tree == 0B) goto <D.29846>; else goto <D.29847>;
              <D.29846>:
              // predicted unlikely by continue predictor.
              goto <D.26571>;
              <D.29847>:
              goto <D.26573>;
              <D.26572>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.26573>:
              if (tree != 0B) goto <D.26572>; else goto <D.26574>;
              <D.26574>:
            }
            <D.26571>:
            bb = bb->next_bb;
            <D.26576>:
            if (bb != 0B) goto <D.26575>; else goto <D.26577>;
            <D.26577>:
            <D.29844>:
            <D.29842>:
            bb = cfg->bb_entry;
            goto <D.26579>;
            <D.26578>:
            D.29848 = cfg->next_vreg;
            bb->max_vreg = D.29848;
            bb = bb->next_bb;
            <D.26579>:
            if (bb != 0B) goto <D.26578>; else goto <D.26580>;
            <D.26580>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.29849>; else goto <D.29850>;
      <D.29849>:
      goto <D.29851>;
      <D.29850>:
      mono_codegen (cfg);
      <D.29851>:
      if (0 != 0) goto <D.29852>; else goto <D.29853>;
      <D.29852>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.29854>;
      <D.29853>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.29854>:
      D.29855 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.29855;
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29450 = D.29449 & 33554432;
      if (D.29450 == 0) goto <D.29856>; else goto <D.29857>;
      <D.29856>:
      mono_save_xdebug_info (cfg);
      <D.29857>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.29543 = cfg->verbose_level;
      if (D.29543 > 1) goto <D.29858>; else goto <D.29859>;
      <D.29858>:
      {
        char * id;

        D.29414 = cfg->method;
        id = mono_method_full_name (D.29414, 0);
        D.29860 = cfg->native_code;
        D.29861 = cfg->code_len;
        D.29862 = (int) D.29861;
        D.29863 = id + 3;
        mono_disassemble_code (cfg, D.29860, D.29862, D.29863);
        monoeg_g_free (id);
      }
      <D.29859>:
      D.29449 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29450 = D.29449 & 33554432;
      if (D.29450 == 0) goto <D.29864>; else goto <D.29865>;
      <D.29864>:
      {
        int ret;

        D.29866 = cfg->domain;
        D.29867 = &D.29866->lock.mutex;
        ret = pthread_mutex_lock (D.29867);
        if (ret != 0) goto <D.29868>; else goto <D.29869>;
        <D.29868>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29869>:
        D.29870 = ret != 0;
        D.29871 = (long int) D.29870;
        D.29872 = __builtin_expect (D.29871, 0);
        if (D.29872 != 0) goto <D.29873>; else goto <D.29874>;
        <D.29873>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.29874>:
      }
      D.29866 = cfg->domain;
      D.29875 = cfg->jit_info;
      mono_jit_info_table_add (D.29866, D.29875);
      D.29414 = cfg->method;
      D.29565 = BIT_FIELD_REF <*D.29414, 64, 256>;
      D.29876 = D.29565 & 18014398509481984;
      if (D.29876 != 0) goto <D.29877>; else goto <D.29878>;
      <D.29877>:
      D.29866 = cfg->domain;
      D.29414 = cfg->method;
      D.29879 = mono_dynamic_code_hash_lookup (D.29866, D.29414);
      D.29875 = cfg->jit_info;
      D.29879->ji = D.29875;
      <D.29878>:
      {
        int ret;

        D.29866 = cfg->domain;
        D.29867 = &D.29866->lock.mutex;
        ret = pthread_mutex_unlock (D.29867);
        if (ret != 0) goto <D.29880>; else goto <D.29881>;
        <D.29880>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29881>:
        D.29882 = ret != 0;
        D.29883 = (long int) D.29882;
        D.29884 = __builtin_expect (D.29883, 0);
        if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
        <D.29885>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.29886>:
      }
      <D.29865>:
      mono_perfcounters.88 = mono_perfcounters;
      D.29888 = mono_perfcounters.88->jit_methods;
      D.29889 = D.29888 + 1;
      mono_perfcounters.88->jit_methods = D.29889;
      mono_perfcounters.88 = mono_perfcounters;
      mono_perfcounters.88 = mono_perfcounters;
      D.29890 = mono_perfcounters.88->jit_bytes;
      D.29572 = header->code_size;
      D.29891 = D.29890 + D.29572;
      mono_perfcounters.88->jit_bytes = D.29891;
      D.29892 = mono_jit_stats.allocated_code_size;
      D.29893 = (unsigned int) D.29892;
      D.29861 = cfg->code_len;
      D.29894 = D.29893 + D.29861;
      D.29895 = (int) D.29894;
      mono_jit_stats.allocated_code_size = D.29895;
      D.29861 = cfg->code_len;
      code_size_ratio = (int) D.29861;
      D.29896 = mono_jit_stats.biggest_method_size;
      if (D.29896 < code_size_ratio) goto <D.29897>; else goto <D.29898>;
      <D.29897>:
      D.29899 = mono_jit_stats.enabled;
      if (D.29899 != 0) goto <D.29900>; else goto <D.29901>;
      <D.29900>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.29902 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.29902);
      D.29350 = method->klass;
      D.29903 = D.29350->name;
      D.29904 = method->name;
      D.29905 = monoeg_g_strdup_printf ("%s::%s)", D.29903, D.29904);
      mono_jit_stats.biggest_method = D.29905;
      <D.29901>:
      <D.29898>:
      D.29906 = code_size_ratio * 100;
      D.29907 = (unsigned int) D.29906;
      D.29572 = header->code_size;
      D.29908 = D.29907 / D.29572;
      code_size_ratio = (int) D.29908;
      D.29909 = mono_jit_stats.max_code_size_ratio;
      if (D.29909 < code_size_ratio) goto <D.29910>; else goto <D.29911>;
      <D.29910>:
      D.29899 = mono_jit_stats.enabled;
      if (D.29899 != 0) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.29914 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.29914);
      D.29350 = method->klass;
      D.29903 = D.29350->name;
      D.29904 = method->name;
      D.29915 = monoeg_g_strdup_printf ("%s::%s)", D.29903, D.29904);
      mono_jit_stats.max_ratio_method = D.29915;
      <D.29913>:
      <D.29911>:
      D.29916 = mono_jit_stats.native_code_size;
      D.29917 = (unsigned int) D.29916;
      D.29861 = cfg->code_len;
      D.29918 = D.29917 + D.29861;
      D.29919 = (int) D.29918;
      mono_jit_stats.native_code_size = D.29919;
      if (0 != 0) goto <D.29920>; else goto <D.29921>;
      <D.29920>:
      <D.29921>:
      D.29457 = cfg;
      return D.29457;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  long unsigned int D.29924;
  long unsigned int D.29925;
  gboolean D.29928;
  struct MonoType * D.29931;
  int D.29932;
  <unnamed-unsigned:22> D.29935;
  int D.29936;
  int D.29939;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.29924 = BIT_FIELD_REF <*method, 64, 256>;
  D.29925 = D.29924 & 2251799813685248;
  if (D.29925 == 0) goto <D.29926>; else goto <D.29927>;
  <D.29926>:
  D.29928 = 0;
  return D.29928;
  <D.29927>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.29929>; else goto <D.29930>;
  <D.29929>:
  i = 0;
  goto <D.26445>;
  <D.26444>:
  D.29931 = inst->type_argv[i];
  D.29932 = is_gsharedvt_type (D.29931);
  if (D.29932 != 0) goto <D.29933>; else goto <D.29934>;
  <D.29933>:
  D.29928 = 1;
  return D.29928;
  <D.29934>:
  i = i + 1;
  <D.26445>:
  D.29935 = inst->type_argc;
  D.29936 = (int) D.29935;
  if (D.29936 > i) goto <D.26444>; else goto <D.26446>;
  <D.26446>:
  <D.29930>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.29937>; else goto <D.29938>;
  <D.29937>:
  i = 0;
  goto <D.26448>;
  <D.26447>:
  D.29931 = inst->type_argv[i];
  D.29939 = is_gsharedvt_type (D.29931);
  if (D.29939 != 0) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  D.29928 = 1;
  return D.29928;
  <D.29941>:
  i = i + 1;
  <D.26448>:
  D.29935 = inst->type_argc;
  D.29936 = (int) D.29935;
  if (D.29936 > i) goto <D.26447>; else goto <D.26449>;
  <D.26449>:
  <D.29938>:
  D.29928 = 0;
  return D.29928;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.29943;
  int iftmp.89;
  unsigned char D.29948;
  struct MonoGenericParam * D.29950;
  short unsigned int D.29951;

  D.29948 = t->type;
  if (D.29948 == 19) goto <D.29945>; else goto <D.29949>;
  <D.29949>:
  D.29948 = t->type;
  if (D.29948 == 30) goto <D.29945>; else goto <D.29946>;
  <D.29945>:
  D.29950 = t->data.generic_param;
  D.29951 = D.29950->serial;
  if (D.29951 == 1) goto <D.29952>; else goto <D.29946>;
  <D.29952>:
  iftmp.89 = 1;
  goto <D.29947>;
  <D.29946>:
  iftmp.89 = 0;
  <D.29947>:
  D.29943 = iftmp.89;
  return D.29943;
}


is_open_method (struct MonoMethod * method)
{
  long unsigned int D.29954;
  long unsigned int D.29955;
  gboolean D.29958;
  struct MonoGenericInst * D.29959;
  long unsigned int D.29962;
  long unsigned int D.29963;
  struct MonoGenericInst * D.29966;
  long unsigned int D.29969;
  long unsigned int D.29970;
  struct MonoGenericContext * context;

  D.29954 = BIT_FIELD_REF <*method, 64, 256>;
  D.29955 = D.29954 & 2251799813685248;
  if (D.29955 == 0) goto <D.29956>; else goto <D.29957>;
  <D.29956>:
  D.29958 = 0;
  return D.29958;
  <D.29957>:
  context = mono_method_get_context (method);
  D.29959 = context->class_inst;
  if (D.29959 != 0B) goto <D.29960>; else goto <D.29961>;
  <D.29960>:
  D.29959 = context->class_inst;
  D.29962 = BIT_FIELD_REF <*D.29959, 64, 0>;
  D.29963 = D.29962 & 512;
  if (D.29963 != 0) goto <D.29964>; else goto <D.29965>;
  <D.29964>:
  D.29958 = 1;
  return D.29958;
  <D.29965>:
  <D.29961>:
  D.29966 = context->method_inst;
  if (D.29966 != 0B) goto <D.29967>; else goto <D.29968>;
  <D.29967>:
  D.29966 = context->method_inst;
  D.29969 = BIT_FIELD_REF <*D.29966, 64, 0>;
  D.29970 = D.29969 & 512;
  if (D.29970 != 0) goto <D.29971>; else goto <D.29972>;
  <D.29971>:
  D.29958 = 1;
  return D.29958;
  <D.29972>:
  <D.29968>:
  D.29958 = 0;
  return D.29958;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.90;
  int iftmp.91;
  int D.29982;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.29975>; else goto <D.29976>;
  <D.29975>:
  if (__ret == 1) goto <D.29978>; else goto <D.29979>;
  <D.29978>:
  iftmp.91 = -1;
  goto <D.29980>;
  <D.29979>:
  iftmp.91 = 1;
  <D.29980>:
  iftmp.90 = iftmp.91;
  goto <D.29981>;
  <D.29976>:
  iftmp.90 = 0;
  <D.29981>:
  __ret = iftmp.90;
  D.29982 = __ret;
  return D.29982;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29984;
  struct MonoType * D.29985;
  int D.29986;
  struct MonoInst * D.29989;
  struct MonoInst * D.29990;
  unsigned char D.29991;
  unsigned char D.29992;
  unsigned int D.29993;
  struct MonoMemPool * D.29996;
  short unsigned int D.29997;
  int D.29998;
  <unnamed-unsigned:1> D.29999;
  int D.30000;
  int D.30001;
  long unsigned int D.30002;
  unsigned int D.30003;
  unsigned int D.30004;
  void * D.30005;
  long unsigned int D.30006;
  long unsigned int D.30007;
  struct MonoInst * * D.30010;
  struct MonoClass * D.30011;
  struct MonoType * D.30012;
  struct MonoInst * D.30013;
  int D.30014;
  long unsigned int D.30015;
  long unsigned int D.30016;
  struct MonoInst * * D.30017;
  struct MonoType * D.30018;
  struct MonoInst * D.30019;
  struct MonoInst * D.30026;
  struct MonoInst * D.30027;
  unsigned int D.30028;
  short unsigned int D.30029;
  unsigned int D.30030;
  unsigned int D.30031;
  void * D.30032;
  struct MonoInst * * D.30035;
  long unsigned int D.30036;
  long unsigned int D.30037;
  struct MonoInst * * D.30038;
  struct MonoType * D.30039;
  struct MonoInst * D.30040;
  int D.30041;
  long unsigned int D.30044;
  long unsigned int D.30045;
  long unsigned int D.30048;
  long unsigned int D.30049;
  struct MonoClass * D.30052;
  struct MonoType * D.30053;
  unsigned char D.30054;
  unsigned char D.30055;
  unsigned char D.30056;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.29984 = cfg->method;
  sig = mono_method_signature (D.29984);
  D.29985 = sig->ret;
  D.29986 = mono_type_is_void (D.29985);
  if (D.29986 == 0) goto <D.29987>; else goto <D.29988>;
  <D.29987>:
  D.29985 = sig->ret;
  D.29989 = mono_compile_create_var (cfg, D.29985, 330);
  cfg->ret = D.29989;
  D.29990 = cfg->ret;
  D.29990 = cfg->ret;
  D.29991 = D.29990->flags;
  D.29992 = D.29991 | 4;
  D.29990->flags = D.29992;
  <D.29988>:
  D.29993 = cfg->verbose_level;
  if (D.29993 > 2) goto <D.29994>; else goto <D.29995>;
  <D.29994>:
  monoeg_g_print ("creating vars\n");
  <D.29995>:
  D.29996 = cfg->mempool;
  D.29997 = sig->param_count;
  D.29998 = (int) D.29997;
  D.29999 = sig->hasthis;
  D.30000 = (int) D.29999;
  D.30001 = D.29998 + D.30000;
  D.30002 = (long unsigned int) D.30001;
  D.30003 = (unsigned int) D.30002;
  D.30004 = D.30003 * 8;
  D.30005 = mono_mempool_alloc0 (D.29996, D.30004);
  cfg->args = D.30005;
  D.30006 = BIT_FIELD_REF <*sig, 64, 64>;
  D.30007 = D.30006 & 512;
  if (D.30007 != 0) goto <D.30008>; else goto <D.30009>;
  <D.30008>:
  D.30010 = cfg->args;
  D.29984 = cfg->method;
  D.30011 = D.29984->klass;
  D.30012 = &D.30011->this_arg;
  D.30013 = mono_compile_create_var (cfg, D.30012, 330);
  *D.30010 = D.30013;
  <D.30009>:
  i = 0;
  goto <D.26201>;
  <D.26200>:
  D.30010 = cfg->args;
  D.29999 = sig->hasthis;
  D.30000 = (int) D.29999;
  D.30014 = D.30000 + i;
  D.30015 = (long unsigned int) D.30014;
  D.30016 = D.30015 * 8;
  D.30017 = D.30010 + D.30016;
  D.30018 = sig->params[i];
  D.30019 = mono_compile_create_var (cfg, D.30018, 330);
  *D.30017 = D.30019;
  i = i + 1;
  <D.26201>:
  D.29997 = sig->param_count;
  D.29998 = (int) D.29997;
  if (D.29998 > i) goto <D.26200>; else goto <D.26202>;
  <D.26202>:
  D.29993 = cfg->verbose_level;
  if (D.29993 > 2) goto <D.30020>; else goto <D.30021>;
  <D.30020>:
  D.29990 = cfg->ret;
  if (D.29990 != 0B) goto <D.30022>; else goto <D.30023>;
  <D.30022>:
  printf ("\treturn : ");
  D.29990 = cfg->ret;
  mono_print_ins (D.29990);
  <D.30023>:
  D.30006 = BIT_FIELD_REF <*sig, 64, 64>;
  D.30007 = D.30006 & 512;
  if (D.30007 != 0) goto <D.30024>; else goto <D.30025>;
  <D.30024>:
  printf ("\tthis: ");
  D.30010 = cfg->args;
  D.30026 = *D.30010;
  mono_print_ins (D.30026);
  <D.30025>:
  i = 0;
  goto <D.26204>;
  <D.26203>:
  printf ("\targ [%d]: ", i);
  D.30010 = cfg->args;
  D.29999 = sig->hasthis;
  D.30000 = (int) D.29999;
  D.30014 = D.30000 + i;
  D.30015 = (long unsigned int) D.30014;
  D.30016 = D.30015 * 8;
  D.30017 = D.30010 + D.30016;
  D.30027 = *D.30017;
  mono_print_ins (D.30027);
  i = i + 1;
  <D.26204>:
  D.29997 = sig->param_count;
  D.29998 = (int) D.29997;
  if (D.29998 > i) goto <D.26203>; else goto <D.26205>;
  <D.26205>:
  <D.30021>:
  D.30028 = cfg->num_varinfo;
  cfg->locals_start = D.30028;
  D.29996 = cfg->mempool;
  D.30029 = header->num_locals;
  D.30030 = (unsigned int) D.30029;
  D.30031 = D.30030 * 8;
  D.30032 = mono_mempool_alloc0 (D.29996, D.30031);
  cfg->locals = D.30032;
  D.29993 = cfg->verbose_level;
  if (D.29993 > 2) goto <D.30033>; else goto <D.30034>;
  <D.30033>:
  monoeg_g_print ("creating locals\n");
  <D.30034>:
  i = 0;
  goto <D.26207>;
  <D.26206>:
  D.30035 = cfg->locals;
  D.30036 = (long unsigned int) i;
  D.30037 = D.30036 * 8;
  D.30038 = D.30035 + D.30037;
  D.30039 = header->locals[i];
  D.30040 = mono_compile_create_var (cfg, D.30039, 329);
  *D.30038 = D.30040;
  i = i + 1;
  <D.26207>:
  D.30029 = header->num_locals;
  D.30041 = (int) D.30029;
  if (D.30041 > i) goto <D.26206>; else goto <D.26208>;
  <D.26208>:
  D.29993 = cfg->verbose_level;
  if (D.29993 > 2) goto <D.30042>; else goto <D.30043>;
  <D.30042>:
  monoeg_g_print ("locals done\n");
  <D.30043>:
  mono_arch_create_vars (cfg);
  D.29984 = cfg->method;
  D.30044 = BIT_FIELD_REF <*D.29984, 64, 256>;
  D.30045 = D.30044 & 36028797018963968;
  if (D.30045 != 0) goto <D.30046>; else goto <D.30047>;
  <D.30046>:
  D.30048 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30049 = D.30048 & 64;
  if (D.30049 != 0) goto <D.30050>; else goto <D.30051>;
  <D.30050>:
  {
    struct MonoInst * lmf_var;

    D.30052 = mono_defaults.int_class;
    D.30053 = &D.30052->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.30053, 329);
    D.30054 = lmf_var->flags;
    D.30055 = D.30054 | 4;
    lmf_var->flags = D.30055;
    D.30054 = lmf_var->flags;
    D.30056 = D.30054 | 32;
    lmf_var->flags = D.30056;
    cfg->lmf_var = lmf_var;
  }
  <D.30051>:
  <D.30047>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.30057;
  long unsigned int D.30060;
  long unsigned int D.30061;
  struct MonoInst * D.30064;
  short unsigned int D.30067;
  short unsigned int D.30068;
  short unsigned int D.30071;
  short unsigned int D.30074;
  struct MonoMemPool * D.30083;
  long int D.30084;
  struct MonoInst * D.30085;
  int D.30086;
  int D.30087;
  const unsigned char * D.30088;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.26337>;
  <D.26336>:
  D.30057 = bb->next_bb;
  if (D.30057 != 0B) goto <D.30058>; else goto <D.30059>;
  <D.30058>:
  D.30057 = bb->next_bb;
  D.30060 = BIT_FIELD_REF <*D.30057, 64, 1472>;
  D.30061 = D.30060 & 140737488355328;
  if (D.30061 != 0) goto <D.30062>; else goto <D.30063>;
  <D.30062>:
  D.30064 = bb->last_ins;
  if (D.30064 != 0B) goto <D.30065>; else goto <D.30066>;
  <D.30065>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  D.30068 = D.30067 + 64985;
  if (D.30068 > 9) goto <D.30069>; else goto <D.30070>;
  <D.30069>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  D.30071 = D.30067 + 64878;
  if (D.30071 > 9) goto <D.30072>; else goto <D.30073>;
  <D.30072>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  D.30074 = D.30067 + 64888;
  if (D.30074 > 9) goto <D.30075>; else goto <D.30076>;
  <D.30075>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  if (D.30067 != 442) goto <D.30077>; else goto <D.30078>;
  <D.30077>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  if (D.30067 != 759) goto <D.30079>; else goto <D.30080>;
  <D.30079>:
  D.30064 = bb->last_ins;
  D.30067 = D.30064->opcode;
  if (D.30067 != 370) goto <D.30081>; else goto <D.30082>;
  <D.30081>:
  {
    struct MonoInst * ins;

    D.30083 = cfg->mempool;
    ins = mono_mempool_alloc (D.30083, 80);
    ins->data.op[1].const_val = 0;
    D.30084 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30084;
    ins->prev = 0B;
    D.30085 = ins->prev;
    ins->next = D.30085;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30086 = ins->sreg3;
    ins->sreg2 = D.30086;
    D.30087 = ins->sreg2;
    ins->sreg1 = D.30087;
    D.30088 = cfg->ip;
    ins->cil_code = D.30088;
    D.30064 = bb->last_ins;
    if (D.30064 != 0B) goto <D.30089>; else goto <D.30090>;
    <D.30089>:
    D.30064 = bb->last_ins;
    D.30064->next = ins;
    D.30064 = bb->last_ins;
    ins->prev = D.30064;
    bb->last_ins = ins;
    goto <D.30091>;
    <D.30090>:
    bb->last_ins = ins;
    D.30064 = bb->last_ins;
    bb->code = D.30064;
    <D.30091>:
    D.30057 = bb->next_bb;
    ins->data.op[0].target_block = D.30057;
  }
  <D.30082>:
  <D.30080>:
  <D.30078>:
  <D.30076>:
  <D.30073>:
  <D.30070>:
  <D.30066>:
  <D.30063>:
  <D.30059>:
  bb = bb->next_bb;
  <D.26337>:
  if (bb != 0B) goto <D.26336>; else goto <D.26338>;
  <D.26338>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.30092;
  unsigned int D.30093;
  unsigned int D.30096;
  struct MonoBasicBlock * * D.30097;
  long unsigned int D.30098;
  long unsigned int D.30099;
  struct MonoBasicBlock * * D.30100;
  struct MonoBasicBlock * D.30101;
  short int D.30102;
  int D.30103;
  int i;

  D.30092 = bb->flags;
  D.30093 = D.30092 & 1;
  if (D.30093 == 0) goto <D.30094>; else goto <D.30095>;
  <D.30094>:
  D.30092 = bb->flags;
  D.30096 = D.30092 | 1;
  bb->flags = D.30096;
  i = 0;
  goto <D.26329>;
  <D.26328>:
  D.30097 = bb->out_bb;
  D.30098 = (long unsigned int) i;
  D.30099 = D.30098 * 8;
  D.30100 = D.30097 + D.30099;
  D.30101 = *D.30100;
  compute_reachable (D.30101);
  i = i + 1;
  <D.26329>:
  D.30102 = bb->out_count;
  D.30103 = (int) D.30102;
  if (D.30103 > i) goto <D.26328>; else goto <D.26330>;
  <D.26330>:
  <D.30095>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30104;
  struct MonoBasicBlock * * D.30105;
  long unsigned int D.30106;
  long unsigned int D.30107;
  struct MonoBasicBlock * * D.30108;
  int D.30109;
  int D.30110;
  struct MonoBasicBlock * * D.30111;
  long unsigned int D.30112;
  long unsigned int D.30113;
  struct MonoBasicBlock * * D.30114;
  struct MonoBasicBlock * D.30115;
  int D.30116;
  short int D.30117;
  int D.30118;
  struct MonoBasicBlock * * D.30119;
  struct MonoBasicBlock * * D.30120;
  struct MonoBasicBlock * D.30121;
  int D.30122;
  short int D.30123;
  int D.30124;
  int iftmp.92;
  struct MonoBasicBlock * D.30126;
  struct MonoBitSet * D.30132;
  int D.30133;
  long unsigned int D.30134;
  long unsigned int D.30135;
  long unsigned int D.30136;
  unsigned int D.30137;
  unsigned int D.30138;
  long unsigned int D.30139;
  long unsigned int D.30140;
  _Bool D.30141;
  long int D.30142;
  long int D.30143;
  guint iftmp.93;
  struct MonoBitSet * D.30152;
  unsigned int D.30155;
  unsigned int i.94;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.30104 = cfg->method;
    method_name = mono_method_full_name (D.30104, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.25794>;
  <D.25793>:
  D.30105 = cfg->bblocks;
  D.30106 = (long unsigned int) i;
  D.30107 = D.30106 * 8;
  D.30108 = D.30105 + D.30107;
  bb = *D.30108;
  code = monoeg_strdup ("\n");
  D.30109 = bb->block_num;
  D.30110 = bb->cil_length;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.30109, i, D.30110, code);
  c = bb->code;
  goto <D.25785>;
  <D.25784>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.25785>:
  if (c != 0B) goto <D.25784>; else goto <D.25786>;
  <D.25786>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.25788>;
  <D.25787>:
  D.30111 = bb->in_bb;
  D.30112 = (long unsigned int) j;
  D.30113 = D.30112 * 8;
  D.30114 = D.30111 + D.30113;
  D.30115 = *D.30114;
  D.30116 = D.30115->block_num;
  monoeg_g_print (" BB%d", D.30116);
  j = j + 1;
  <D.25788>:
  D.30117 = bb->in_count;
  D.30118 = (int) D.30117;
  if (D.30118 > j) goto <D.25787>; else goto <D.25789>;
  <D.25789>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.25791>;
  <D.25790>:
  D.30119 = bb->out_bb;
  D.30112 = (long unsigned int) j;
  D.30113 = D.30112 * 8;
  D.30120 = D.30119 + D.30113;
  D.30121 = *D.30120;
  D.30122 = D.30121->block_num;
  monoeg_g_print (" BB%d", D.30122);
  j = j + 1;
  <D.25791>:
  D.30123 = bb->out_count;
  D.30124 = (int) D.30123;
  if (D.30124 > j) goto <D.25790>; else goto <D.25792>;
  <D.25792>:
  D.30126 = bb->idom;
  if (D.30126 != 0B) goto <D.30127>; else goto <D.30128>;
  <D.30127>:
  D.30126 = bb->idom;
  iftmp.92 = D.30126->block_num;
  goto <D.30129>;
  <D.30128>:
  iftmp.92 = -1;
  <D.30129>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.92);
  D.30126 = bb->idom;
  if (D.30126 != 0B) goto <D.30130>; else goto <D.30131>;
  <D.30130>:
  D.30132 = bb->dominators;
  D.30126 = bb->idom;
  D.30133 = D.30126->dfn;
  D.30134 = (long unsigned int) D.30133;
  D.30135 = D.30134 / 64;
  D.30136 = D.30132->data[D.30135];
  D.30126 = bb->idom;
  D.30133 = D.30126->dfn;
  D.30137 = (unsigned int) D.30133;
  D.30138 = D.30137 & 63;
  D.30139 = D.30136 >> D.30138;
  D.30140 = D.30139 & 1;
  D.30141 = D.30140 == 0;
  D.30142 = (long int) D.30141;
  D.30143 = __builtin_expect (D.30142, 0);
  if (D.30143 != 0) goto <D.30144>; else goto <D.30145>;
  <D.30144>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2465, "mono_bitset_test_fast (bb->dominators, bb->idom->dfn)");
  <D.30145>:
  <D.30131>:
  D.30132 = bb->dominators;
  if (D.30132 != 0B) goto <D.30146>; else goto <D.30147>;
  <D.30146>:
  D.30132 = bb->dominators;
  D.30126 = bb->idom;
  if (D.30126 != 0B) goto <D.30149>; else goto <D.30150>;
  <D.30149>:
  D.30126 = bb->idom;
  D.30133 = D.30126->dfn;
  iftmp.93 = (guint) D.30133;
  goto <D.30151>;
  <D.30150>:
  iftmp.93 = 4294967295;
  <D.30151>:
  mono_blockset_print (cfg, D.30132, "\tdominators", iftmp.93);
  <D.30147>:
  D.30152 = bb->dfrontier;
  if (D.30152 != 0B) goto <D.30153>; else goto <D.30154>;
  <D.30153>:
  D.30152 = bb->dfrontier;
  mono_blockset_print (cfg, D.30152, "\tdfrontier", 4294967295);
  <D.30154>:
  monoeg_g_free (code);
  i = i + 1;
  <D.25794>:
  D.30155 = cfg->num_bblocks;
  i.94 = (unsigned int) i;
  if (D.30155 > i.94) goto <D.25793>; else goto <D.25795>;
  <D.25795>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.30157;
  long unsigned int D.30158;
  long unsigned int D.30159;
  struct MonoBasicBlock * * D.30160;
  struct MonoBasicBlock * * D.30161;
  long unsigned int D.30162;
  long unsigned int D.30163;
  struct MonoBasicBlock * * D.30164;
  struct MonoBasicBlock * D.30165;
  int D.30166;
  int D.30169;
  short int D.30170;
  int D.30171;
  int i;

  D.30157 = *dfn;
  D.30158 = (long unsigned int) D.30157;
  D.30159 = D.30158 * 8;
  D.30160 = array + D.30159;
  *D.30160 = start;
  i = 0;
  goto <D.25288>;
  <D.25287>:
  D.30161 = start->out_bb;
  D.30162 = (long unsigned int) i;
  D.30163 = D.30162 * 8;
  D.30164 = D.30161 + D.30163;
  D.30165 = *D.30164;
  D.30166 = D.30165->dfn;
  if (D.30166 != 0) goto <D.30167>; else goto <D.30168>;
  <D.30167>:
  // predicted unlikely by continue predictor.
  goto <D.25286>;
  <D.30168>:
  D.30157 = *dfn;
  D.30169 = D.30157 + 1;
  *dfn = D.30169;
  D.30161 = start->out_bb;
  D.30162 = (long unsigned int) i;
  D.30163 = D.30162 * 8;
  D.30164 = D.30161 + D.30163;
  D.30165 = *D.30164;
  D.30157 = *dfn;
  D.30165->dfn = D.30157;
  D.30161 = start->out_bb;
  D.30162 = (long unsigned int) i;
  D.30163 = D.30162 * 8;
  D.30164 = D.30161 + D.30163;
  D.30165 = *D.30164;
  D.30165->df_parent = start;
  D.30157 = *dfn;
  D.30158 = (long unsigned int) D.30157;
  D.30159 = D.30158 * 8;
  D.30160 = array + D.30159;
  D.30161 = start->out_bb;
  D.30162 = (long unsigned int) i;
  D.30163 = D.30162 * 8;
  D.30164 = D.30161 + D.30163;
  D.30165 = *D.30164;
  *D.30160 = D.30165;
  D.30161 = start->out_bb;
  D.30162 = (long unsigned int) i;
  D.30163 = D.30162 * 8;
  D.30164 = D.30161 + D.30163;
  D.30165 = *D.30164;
  df_visit (D.30165, dfn, array);
  <D.25286>:
  i = i + 1;
  <D.25288>:
  D.30170 = start->out_count;
  D.30171 = (int) D.30170;
  if (D.30171 > i) goto <D.25287>; else goto <D.25289>;
  <D.25289>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30172;
  unsigned int D.30173;

  D.30173 = __sync_add_and_fetch_4 (val, 1);
  D.30172 = (gint32) D.30173;
  return D.30172;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.30175;
  _Bool D.30176;
  long int D.30177;
  long int D.30178;
  struct MonoGenericSharingContext * D.30181;
  long unsigned int D.30185;
  long unsigned int D.30186;
  struct MonoMethod * D.30189;
  short unsigned int D.30190;
  int D.30191;
  int D.30192;
  long unsigned int D.30193;
  long unsigned int D.30194;
  int D.30195;
  struct GSList * D.30198;
  struct MonoBasicBlock * D.30201;
  int D.30202;
  int D.30203;
  struct MonoBasicBlock * * D.30204;
  unsigned int D.30205;
  unsigned int D.30206;
  unsigned int D.30207;
  long unsigned int D.30208;
  long unsigned int D.30209;
  struct MonoBasicBlock * * D.30210;
  _Bool D.30211;
  long int D.30212;
  long int D.30213;
  int D.30216;
  long unsigned int D.30221;
  unsigned int D.30222;
  unsigned int D.30223;
  unsigned int D.30224;
  unsigned int D.30225;
  _Bool D.30226;
  long int D.30227;
  long int D.30228;
  unsigned char D.30231;
  unsigned int D.30236;
  <unnamed-unsigned:15> D.30238;
  long unsigned int D.30239;
  long unsigned int D.30240;
  long unsigned int D.30243;
  long unsigned int D.30244;
  long unsigned int D.30245;
  long unsigned int D.30246;
  long unsigned int D.30247;
  long unsigned int D.30248;
  long unsigned int D.30249;
  long unsigned int D.30250;
  long unsigned int D.30251;
  long unsigned int D.30252;
  long unsigned int D.30253;
  struct MonoDomain * D.30255;
  unsigned int D.30256;
  unsigned int D.30257;
  unsigned int generic_info_size.95;
  unsigned int D.30259;
  unsigned int holes_size.96;
  unsigned int D.30261;
  unsigned int arch_eh_info_size.97;
  unsigned int D.30263;
  unsigned int cas_size.98;
  unsigned int D.30265;
  unsigned int D.30266;
  unsigned char * D.30267;
  unsigned int D.30268;
  int D.30269;
  long unsigned int D.30270;
  unsigned int D.30271;
  unsigned int D.30272;
  unsigned int D.30273;
  _Bool D.30274;
  <unnamed-signed:1> D.30275;
  short unsigned int D.30276;
  <unnamed-unsigned:15> D.30277;
  _Bool D.30282;
  long int D.30283;
  long int D.30284;
  void * D.30289;
  void * D.30291;
  struct MonoGenericSharingContext * D.30292;
  short unsigned int D.30295;
  int D.30296;
  int D.30297;
  struct MonoGenericContext * D.30299;
  struct MonoGenericInst * D.30300;
  struct MonoClass * D.30302;
  long unsigned int D.30303;
  long unsigned int D.30304;
  struct MonoInst * D.30305;
  _Bool D.30306;
  long int D.30307;
  long int D.30308;
  struct MonoGenericContext * D.30315;
  struct MonoGenericInst * D.30316;
  short unsigned int D.30320;
  _Bool D.30321;
  long int D.30322;
  long int D.30323;
  struct MonoInst * * D.30326;
  unsigned int D.30329;
  int D.30330;
  int D.30333;
  long unsigned int D.30334;
  long unsigned int D.30335;
  void * D.30336;
  unsigned int D.30338;
  unsigned int D.30339;
  void * D.30340;
  struct MonoDwarfLocListEntry * D.30341;
  long unsigned int D.30342;
  long unsigned int D.30343;
  struct MonoDwarfLocListEntry * D.30344;
  void * D.30345;
  int D.30348;
  _Bool D.30349;
  long int D.30350;
  long int D.30351;
  unsigned char D.30354;
  int D.30355;
  int D.30359;
  unsigned char D.30360;
  long int D.30364;
  unsigned long D.30365;
  unsigned long D.30366;
  _Bool D.30367;
  long int D.30368;
  long int D.30369;
  int D.30372;
  unsigned char D.30373;
  int D.30374;
  short unsigned int D.30377;
  struct MonoBasicBlock * D.30378;
  int D.30379;
  int D.30380;
  unsigned int D.30381;
  unsigned int D.30382;
  unsigned int D.30383;
  long unsigned int D.30384;
  long unsigned int D.30385;
  struct MonoBasicBlock * * D.30386;
  _Bool D.30387;
  long int D.30388;
  long int D.30389;
  int D.30392;
  int D.30395;
  int D.30396;
  int i.99;
  struct MonoExceptionClause * D.30398;
  long int D.30399;
  struct MonoExceptionClause * D.30400;
  long int D.30401;
  long int D.30402;
  long int D.30403;
  short unsigned int D.30404;
  unsigned int D.30405;
  short unsigned int D.30406;
  short unsigned int D.30407;
  short unsigned int D.30408;
  short unsigned int D.30411;
  int D.30412;
  unsigned int D.30413;
  short unsigned int D.30414;
  int D.30415;
  _Bool D.30416;
  long int D.30417;
  long int D.30418;
  struct MonoJitExceptionInfo * D.30429;
  struct MonoJitExceptionInfo * D.30430;
  long unsigned int D.30432;
  long unsigned int D.30433;
  long unsigned int D.30436;
  long unsigned int D.30437;
  unsigned int D.30438;
  unsigned int D.30439;
  int D.30440;
  gint32 iftmp.100;
  long int D.30444;
  unsigned int D.30446;
  unsigned int D.30449;
  long unsigned int D.30450;
  long unsigned int D.30451;
  struct MonoBasicBlock * * D.30452;
  _Bool D.30453;
  long int D.30454;
  long int D.30455;
  int D.30458;
  sizetype D.30459;
  unsigned char * D.30460;
  struct MonoClass * D.30462;
  unsigned int D.30463;
  long unsigned int D.30464;
  long unsigned int D.30465;
  struct MonoBasicBlock * * D.30466;
  _Bool D.30469;
  long int D.30470;
  long int D.30471;
  long unsigned int D.30474;
  long unsigned int D.30475;
  void * D.30478;
  void * D.30479;
  unsigned int D.30480;
  unsigned int D.30481;
  long unsigned int D.30482;
  long unsigned int D.30483;
  struct MonoBasicBlock * * D.30484;
  long unsigned int D.30489;
  long unsigned int D.30490;
  struct MonoBasicBlock * * D.30491;
  int D.30494;
  long unsigned int D.30499;
  long unsigned int D.30500;
  struct MonoBasicBlock * * D.30501;
  struct MonoBasicBlock * D.30504;
  int D.30505;
  int D.30506;
  int D.30507;
  sizetype D.30508;
  struct MonoExceptionClause * D.30509;
  void * D.30512;
  long int D.30517;
  long int D.30518;
  long int D.30519;
  int D.30520;
  int D.30521;
  sizetype D.30522;
  unsigned char * D.30523;
  unsigned int D.30526;
  unsigned int D.30527;
  unsigned int D.30528;
  long unsigned int D.30531;
  long unsigned int D.30532;
  struct MonoBasicBlock * * D.30533;
  long unsigned int D.30537;
  long unsigned int D.30538;
  struct MonoBasicBlock * * D.30539;
  int D.30542;
  int D.30545;
  unsigned int D.30547;
  sizetype D.30548;
  unsigned char * D.30549;
  int D.30550;
  void * D.30553;
  long int D.30554;
  long int D.30555;
  void * D.30556;
  long int D.30557;
  long int D.30558;
  void * D.30559;
  long int D.30560;
  long int D.30561;
  void * D.30562;
  long int D.30563;
  long int D.30564;
  unsigned int D.30565;
  <unnamed-unsigned:15> D.30566;
  int D.30567;
  guint8 * D.30568;
  unsigned int D.30571;
  unsigned int D.30572;
  struct GSList * D.30574;
  unsigned int info_len.101;
  unsigned int D.30578;
  struct MonoJitInfo * D.30579;
  struct GSList * tmp;
  struct MonoMethodHeader * header;
  struct MonoJitInfo * jinfo;
  int num_clauses;
  int generic_info_size;
  int arch_eh_info_size;
  int holes_size;
  int num_holes;
  int cas_size;
  guint32 stack_size;

  arch_eh_info_size = 0;
  holes_size = 0;
  num_holes = 0;
  cas_size = 0;
  stack_size = 0;
  D.30175 = cfg->method;
  D.30176 = D.30175 != method_to_compile;
  D.30177 = (long int) D.30176;
  D.30178 = __builtin_expect (D.30177, 0);
  if (D.30178 != 0) goto <D.30179>; else goto <D.30180>;
  <D.30179>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.30180>:
  header = cfg->header;
  D.30181 = cfg->generic_sharing_context;
  if (D.30181 != 0B) goto <D.30182>; else goto <D.30183>;
  <D.30182>:
  generic_info_size = 32;
  goto <D.30184>;
  <D.30183>:
  generic_info_size = 0;
  <D.30184>:
  D.30185 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.30186 = D.30185 & 18014398509481984;
  if (D.30186 != 0) goto <D.30187>; else goto <D.30188>;
  <D.30187>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.30189 = cfg->method_to_register;
    sig = mono_method_signature (D.30189);
    D.30190 = sig->param_count;
    D.30191 = (int) D.30190;
    D.30192 = D.30191 + 1;
    D.30193 = (long unsigned int) D.30192;
    D.30194 = D.30193 * 6;
    arg_info = __builtin_alloca (D.30194);
    D.30181 = cfg->generic_sharing_context;
    D.30190 = sig->param_count;
    D.30191 = (int) D.30190;
    D.30195 = mono_arch_get_argument_info (D.30181, sig, D.30191, arg_info);
    stack_size = (guint32) D.30195;
    if (stack_size != 0) goto <D.30196>; else goto <D.30197>;
    <D.30196>:
    arch_eh_info_size = 4;
    <D.30197>:
  }
  <D.30188>:
  D.30198 = cfg->try_block_holes;
  if (D.30198 != 0B) goto <D.30199>; else goto <D.30200>;
  <D.30199>:
  tmp = cfg->try_block_holes;
  goto <D.26368>;
  <D.26367>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.30201 = hole->basic_block;
    D.30202 = D.30201->native_offset;
    D.30201 = hole->basic_block;
    D.30203 = D.30201->native_length;
    hole_end = D.30202 + D.30203;
    D.30204 = cfg->cil_offset_to_bb;
    D.30205 = ec->try_offset;
    D.30206 = ec->try_len;
    D.30207 = D.30205 + D.30206;
    D.30208 = (long unsigned int) D.30207;
    D.30209 = D.30208 * 8;
    D.30210 = D.30204 + D.30209;
    clause_last_bb = *D.30210;
    D.30211 = clause_last_bb == 0B;
    D.30212 = (long int) D.30211;
    D.30213 = __builtin_expect (D.30212, 0);
    if (D.30213 != 0) goto <D.30214>; else goto <D.30215>;
    <D.30214>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.30215>:
    D.30216 = clause_last_bb->native_offset;
    if (D.30216 != hole_end) goto <D.30217>; else goto <D.30218>;
    <D.30217>:
    num_holes = num_holes + 1;
    <D.30218>:
  }
  tmp = tmp->next;
  <D.26368>:
  if (tmp != 0B) goto <D.26367>; else goto <D.26369>;
  <D.26369>:
  if (num_holes != 0) goto <D.30219>; else goto <D.30220>;
  <D.30219>:
  D.30221 = (long unsigned int) num_holes;
  D.30222 = (unsigned int) D.30221;
  D.30223 = D.30222 * 8;
  D.30224 = D.30223 + 4;
  holes_size = (int) D.30224;
  <D.30220>:
  D.30225 = cfg->verbose_level;
  D.30226 = D.30225 > 3;
  D.30227 = (long int) D.30226;
  D.30228 = __builtin_expect (D.30227, 0);
  if (D.30228 != 0) goto <D.30229>; else goto <D.30230>;
  <D.30229>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.30230>:
  <D.30200>:
  D.30189 = cfg->method_to_register;
  D.30231 = mono_method_has_declsec (D.30189);
  if (D.30231 != 0) goto <D.30232>; else goto <D.30233>;
  <D.30232>:
  cas_size = 4;
  <D.30233>:
  if (0 != 0) goto <D.30234>; else goto <D.30235>;
  <D.30234>:
  D.30236 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.30236;
  goto <D.30237>;
  <D.30235>:
  D.30238 = header->num_clauses;
  num_clauses = (int) D.30238;
  <D.30237>:
  D.30175 = cfg->method;
  D.30239 = BIT_FIELD_REF <*D.30175, 64, 256>;
  D.30240 = D.30239 & 18014398509481984;
  if (D.30240 != 0) goto <D.30241>; else goto <D.30242>;
  <D.30241>:
  D.30243 = (long unsigned int) num_clauses;
  D.30244 = D.30243 * 40;
  D.30245 = (long unsigned int) generic_info_size;
  D.30246 = D.30244 + D.30245;
  D.30247 = (long unsigned int) holes_size;
  D.30248 = D.30246 + D.30247;
  D.30249 = (long unsigned int) arch_eh_info_size;
  D.30250 = D.30248 + D.30249;
  D.30251 = (long unsigned int) cas_size;
  D.30252 = D.30250 + D.30251;
  D.30253 = D.30252 + 48;
  jinfo = monoeg_malloc0 (D.30253);
  goto <D.30254>;
  <D.30242>:
  D.30255 = cfg->domain;
  D.30243 = (long unsigned int) num_clauses;
  D.30256 = (unsigned int) D.30243;
  D.30257 = D.30256 * 40;
  generic_info_size.95 = (unsigned int) generic_info_size;
  D.30259 = D.30257 + generic_info_size.95;
  holes_size.96 = (unsigned int) holes_size;
  D.30261 = D.30259 + holes_size.96;
  arch_eh_info_size.97 = (unsigned int) arch_eh_info_size;
  D.30263 = D.30261 + arch_eh_info_size.97;
  cas_size.98 = (unsigned int) cas_size;
  D.30265 = D.30263 + cas_size.98;
  D.30266 = D.30265 + 48;
  jinfo = mono_domain_alloc0 (D.30255, D.30266);
  <D.30254>:
  D.30189 = cfg->method_to_register;
  jinfo->d.method = D.30189;
  D.30267 = cfg->native_code;
  jinfo->code_start = D.30267;
  D.30268 = cfg->code_len;
  D.30269 = (int) D.30268;
  jinfo->code_size = D.30269;
  D.30270 = cfg->used_int_regs;
  D.30271 = (unsigned int) D.30270;
  jinfo->used_regs = D.30271;
  D.30272 = cfg->opt;
  D.30273 = D.30272 & 512;
  D.30274 = D.30273 != 0;
  D.30275 = (<unnamed-signed:1>) D.30274;
  jinfo->domain_neutral = D.30275;
  D.30276 = (short unsigned int) num_clauses;
  D.30277 = (<unnamed-unsigned:15>) D.30276;
  jinfo->num_clauses = D.30277;
  if (0 != 0) goto <D.30278>; else goto <D.30279>;
  <D.30278>:
  jinfo->from_llvm = -1;
  <D.30279>:
  D.30181 = cfg->generic_sharing_context;
  if (D.30181 != 0B) goto <D.30280>; else goto <D.30281>;
  <D.30280>:
  {
    struct MonoInst * inst;
    struct MonoGenericJitInfo * gi;
    struct GSList * loclist;

    loclist = 0B;
    jinfo->has_generic_jit_info = -1;
    gi = mono_jit_info_get_generic_jit_info (jinfo);
    D.30282 = gi == 0B;
    D.30283 = (long int) D.30282;
    D.30284 = __builtin_expect (D.30283, 0);
    if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
    <D.30285>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.30286>:
    D.30175 = cfg->method;
    D.30239 = BIT_FIELD_REF <*D.30175, 64, 256>;
    D.30240 = D.30239 & 18014398509481984;
    if (D.30240 != 0) goto <D.30287>; else goto <D.30288>;
    <D.30287>:
    D.30289 = monoeg_malloc0 (16);
    gi->generic_sharing_context = D.30289;
    goto <D.30290>;
    <D.30288>:
    D.30255 = cfg->domain;
    D.30291 = mono_domain_alloc0 (D.30255, 16);
    gi->generic_sharing_context = D.30291;
    <D.30290>:
    D.30292 = gi->generic_sharing_context;
    D.30181 = cfg->generic_sharing_context;
    memcpy (D.30292, D.30181, 16);
    D.30295 = method_to_compile->flags;
    D.30296 = (int) D.30295;
    D.30297 = D.30296 & 16;
    if (D.30297 != 0) goto <D.30293>; else goto <D.30298>;
    <D.30298>:
    D.30299 = mini_method_get_context (method_to_compile);
    D.30300 = D.30299->method_inst;
    if (D.30300 != 0B) goto <D.30293>; else goto <D.30301>;
    <D.30301>:
    D.30302 = method_to_compile->klass;
    D.30303 = BIT_FIELD_REF <*D.30302, 64, 256>;
    D.30304 = D.30303 & 1152921504606846976;
    if (D.30304 != 0) goto <D.30293>; else goto <D.30294>;
    <D.30293>:
    D.30305 = cfg->rgctx_var;
    D.30306 = D.30305 == 0B;
    D.30307 = (long int) D.30306;
    D.30308 = __builtin_expect (D.30307, 0);
    if (D.30308 != 0) goto <D.30309>; else goto <D.30310>;
    <D.30309>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.30310>:
    <D.30294>:
    gi->has_this = -1;
    D.30295 = method_to_compile->flags;
    D.30296 = (int) D.30295;
    D.30297 = D.30296 & 16;
    if (D.30297 != 0) goto <D.30311>; else goto <D.30314>;
    <D.30314>:
    D.30315 = mini_method_get_context (method_to_compile);
    D.30316 = D.30315->method_inst;
    if (D.30316 != 0B) goto <D.30311>; else goto <D.30317>;
    <D.30317>:
    D.30302 = method_to_compile->klass;
    D.30303 = BIT_FIELD_REF <*D.30302, 64, 256>;
    D.30304 = D.30303 & 1152921504606846976;
    if (D.30304 != 0) goto <D.30311>; else goto <D.30312>;
    <D.30311>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.30318>; else goto <D.30319>;
    <D.30318>:
    D.30320 = inst->opcode;
    D.30321 = D.30320 != 367;
    D.30322 = (long int) D.30321;
    D.30323 = __builtin_expect (D.30322, 0);
    if (D.30323 != 0) goto <D.30324>; else goto <D.30325>;
    <D.30324>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4378, "inst->opcode == OP_REGOFFSET");
    <D.30325>:
    <D.30319>:
    loclist = cfg->rgctx_loclist;
    goto <D.30313>;
    <D.30312>:
    D.30326 = cfg->args;
    inst = *D.30326;
    loclist = cfg->this_loclist;
    <D.30313>:
    if (loclist != 0B) goto <D.30327>; else goto <D.30328>;
    <D.30327>:
    {
      struct GSList * l;
      int i;

      D.30329 = monoeg_g_slist_length (loclist);
      D.30330 = (int) D.30329;
      gi->nlocs = D.30330;
      D.30175 = cfg->method;
      D.30239 = BIT_FIELD_REF <*D.30175, 64, 256>;
      D.30240 = D.30239 & 18014398509481984;
      if (D.30240 != 0) goto <D.30331>; else goto <D.30332>;
      <D.30331>:
      D.30333 = gi->nlocs;
      D.30334 = (long unsigned int) D.30333;
      D.30335 = D.30334 * 20;
      D.30336 = monoeg_malloc0 (D.30335);
      gi->locations = D.30336;
      goto <D.30337>;
      <D.30332>:
      D.30255 = cfg->domain;
      D.30333 = gi->nlocs;
      D.30334 = (long unsigned int) D.30333;
      D.30338 = (unsigned int) D.30334;
      D.30339 = D.30338 * 20;
      D.30340 = mono_domain_alloc0 (D.30255, D.30339);
      gi->locations = D.30340;
      <D.30337>:
      i = 0;
      l = loclist;
      goto <D.26376>;
      <D.26375>:
      D.30341 = gi->locations;
      D.30342 = (long unsigned int) i;
      D.30343 = D.30342 * 20;
      D.30344 = D.30341 + D.30343;
      D.30345 = l->data;
      memcpy (D.30344, D.30345, 20);
      i = i + 1;
      l = l->next;
      <D.26376>:
      if (l != 0B) goto <D.26375>; else goto <D.26377>;
      <D.26377>:
    }
    <D.30328>:
    if (0 != 0) goto <D.30346>; else goto <D.30347>;
    <D.30346>:
    D.30348 = cfg->llvm_this_reg;
    D.30349 = D.30348 == -1;
    D.30350 = (long int) D.30349;
    D.30351 = __builtin_expect (D.30350, 0);
    if (D.30351 != 0) goto <D.30352>; else goto <D.30353>;
    <D.30352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.30353>:
    gi->this_in_reg = 0;
    D.30348 = cfg->llvm_this_reg;
    D.30354 = (unsigned char) D.30348;
    gi->this_reg = D.30354;
    D.30355 = cfg->llvm_this_offset;
    gi->this_offset = D.30355;
    goto <D.30356>;
    <D.30347>:
    D.30320 = inst->opcode;
    if (D.30320 == 366) goto <D.30357>; else goto <D.30358>;
    <D.30357>:
    gi->this_in_reg = -1;
    D.30359 = inst->dreg;
    D.30360 = (unsigned char) D.30359;
    gi->this_reg = D.30360;
    goto <D.30361>;
    <D.30358>:
    D.30320 = inst->opcode;
    D.30321 = D.30320 != 367;
    D.30322 = (long int) D.30321;
    D.30323 = __builtin_expect (D.30322, 0);
    if (D.30323 != 0) goto <D.30362>; else goto <D.30363>;
    <D.30362>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.30363>:
    D.30364 = inst->data.op[0].const_val;
    D.30365 = (unsigned long) D.30364;
    D.30366 = D.30365 + 2147483648;
    D.30367 = D.30366 > 4294967295;
    D.30368 = (long int) D.30367;
    D.30369 = __builtin_expect (D.30368, 0);
    if (D.30369 != 0) goto <D.30370>; else goto <D.30371>;
    <D.30370>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4417, "inst->inst_offset >= G_MININT32 && inst->inst_offset <= G_MAXINT32");
    <D.30371>:
    gi->this_in_reg = 0;
    D.30372 = inst->sreg1;
    D.30373 = (unsigned char) D.30372;
    gi->this_reg = D.30373;
    D.30364 = inst->data.op[0].const_val;
    D.30374 = (int) D.30364;
    gi->this_offset = D.30374;
    <D.30361>:
    <D.30356>:
  }
  <D.30281>:
  if (num_holes != 0) goto <D.30375>; else goto <D.30376>;
  <D.30375>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.30377 = (short unsigned int) num_holes;
    table->num_holes = D.30377;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.26388>;
    <D.26387>:
    {
      guint32 start_bb_offset;
      struct MonoTryBlockHoleJitInfo * hole;
      struct TryBlockHole * hole_data;
      struct MonoExceptionClause * ec;
      int hole_end;
      struct MonoBasicBlock * clause_last_bb;

      hole_data = tmp->data;
      ec = hole_data->clause;
      D.30378 = hole_data->basic_block;
      D.30379 = D.30378->native_offset;
      D.30378 = hole_data->basic_block;
      D.30380 = D.30378->native_length;
      hole_end = D.30379 + D.30380;
      D.30204 = cfg->cil_offset_to_bb;
      D.30381 = ec->try_offset;
      D.30382 = ec->try_len;
      D.30383 = D.30381 + D.30382;
      D.30384 = (long unsigned int) D.30383;
      D.30385 = D.30384 * 8;
      D.30386 = D.30204 + D.30385;
      clause_last_bb = *D.30386;
      D.30387 = clause_last_bb == 0B;
      D.30388 = (long int) D.30387;
      D.30389 = __builtin_expect (D.30388, 0);
      if (D.30389 != 0) goto <D.30390>; else goto <D.30391>;
      <D.30390>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.30391>:
      D.30392 = clause_last_bb->native_offset;
      if (D.30392 == hole_end) goto <D.30393>; else goto <D.30394>;
      <D.30393>:
      // predicted unlikely by continue predictor.
      goto <D.26386>;
      <D.30394>:
      D.30395 = hole_data->start_offset;
      D.30378 = hole_data->basic_block;
      D.30379 = D.30378->native_offset;
      D.30396 = D.30395 - D.30379;
      start_bb_offset = (guint32) D.30396;
      i.99 = i;
      i = i.99 + 1;
      hole = &table->holes[i.99];
      D.30398 = hole_data->clause;
      D.30399 = (long int) D.30398;
      D.30400 = header->clauses;
      D.30401 = (long int) D.30400;
      D.30402 = D.30399 - D.30401;
      D.30403 = D.30402 /[ex] 32;
      D.30404 = (short unsigned int) D.30403;
      hole->clause = D.30404;
      D.30395 = hole_data->start_offset;
      D.30405 = (unsigned int) D.30395;
      hole->offset = D.30405;
      D.30378 = hole_data->basic_block;
      D.30380 = D.30378->native_length;
      D.30406 = (short unsigned int) D.30380;
      D.30407 = (short unsigned int) start_bb_offset;
      D.30408 = D.30406 - D.30407;
      hole->length = D.30408;
      D.30225 = cfg->verbose_level;
      D.30226 = D.30225 > 3;
      D.30227 = (long int) D.30226;
      D.30228 = __builtin_expect (D.30227, 0);
      if (D.30228 != 0) goto <D.30409>; else goto <D.30410>;
      <D.30409>:
      D.30411 = hole->clause;
      D.30412 = (int) D.30411;
      D.30413 = hole->offset;
      D.30414 = hole->length;
      D.30415 = (int) D.30414;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.30412, D.30413, D.30415);
      <D.30410>:
    }
    <D.26386>:
    tmp = tmp->next;
    <D.26388>:
    if (tmp != 0B) goto <D.26387>; else goto <D.26389>;
    <D.26389>:
    D.30416 = i != num_holes;
    D.30417 = (long int) D.30416;
    D.30418 = __builtin_expect (D.30417, 0);
    if (D.30418 != 0) goto <D.30419>; else goto <D.30420>;
    <D.30419>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.30420>:
  }
  <D.30376>:
  if (arch_eh_info_size != 0) goto <D.30421>; else goto <D.30422>;
  <D.30421>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.30422>:
  if (cas_size != 0) goto <D.30423>; else goto <D.30424>;
  <D.30423>:
  jinfo->has_cas_info = -1;
  <D.30424>:
  if (0 != 0) goto <D.30425>; else goto <D.30426>;
  <D.30425>:
  if (num_clauses != 0) goto <D.30427>; else goto <D.30428>;
  <D.30427>:
  D.30429 = &jinfo->clauses[0];
  D.30430 = cfg->llvm_ex_info;
  D.30243 = (long unsigned int) num_clauses;
  D.30244 = D.30243 * 40;
  memcpy (D.30429, D.30430, D.30244);
  <D.30428>:
  goto <D.30431>;
  <D.30426>:
  D.30432 = BIT_FIELD_REF <*header, 64, 64>;
  D.30433 = D.30432 & 65534;
  if (D.30433 != 0) goto <D.30434>; else goto <D.30435>;
  <D.30434>:
  {
    int i;

    i = 0;
    goto <D.26415>;
    <D.26414>:
    {
      struct MonoExceptionClause * ec;
      struct MonoJitExceptionInfo * ei;
      struct MonoBasicBlock * tblock;
      struct MonoInst * exvar;

      D.30400 = header->clauses;
      D.30436 = (long unsigned int) i;
      D.30437 = D.30436 * 32;
      ec = D.30400 + D.30437;
      ei = &jinfo->clauses[i];
      D.30438 = ec->flags;
      ei->flags = D.30438;
      D.30439 = ec->handler_offset;
      D.30440 = (int) D.30439;
      exvar = mono_find_exvar_for_offset (cfg, D.30440);
      if (exvar != 0B) goto <D.30442>; else goto <D.30443>;
      <D.30442>:
      D.30444 = exvar->data.op[0].const_val;
      iftmp.100 = (gint32) D.30444;
      goto <D.30445>;
      <D.30443>:
      iftmp.100 = 0;
      <D.30445>:
      ei->exvar_offset = iftmp.100;
      D.30446 = ei->flags;
      if (D.30446 == 1) goto <D.30447>; else goto <D.30448>;
      <D.30447>:
      D.30204 = cfg->cil_offset_to_bb;
      D.30449 = ec->data.filter_offset;
      D.30450 = (long unsigned int) D.30449;
      D.30451 = D.30450 * 8;
      D.30452 = D.30204 + D.30451;
      tblock = *D.30452;
      D.30453 = tblock == 0B;
      D.30454 = (long int) D.30453;
      D.30455 = __builtin_expect (D.30454, 0);
      if (D.30455 != 0) goto <D.30456>; else goto <D.30457>;
      <D.30456>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.30457>:
      D.30267 = cfg->native_code;
      D.30458 = tblock->native_offset;
      D.30459 = (sizetype) D.30458;
      D.30460 = D.30267 + D.30459;
      ei->data.filter = D.30460;
      goto <D.30461>;
      <D.30448>:
      D.30462 = ec->data.catch_class;
      ei->data.catch_class = D.30462;
      <D.30461>:
      D.30204 = cfg->cil_offset_to_bb;
      D.30463 = ec->try_offset;
      D.30464 = (long unsigned int) D.30463;
      D.30465 = D.30464 * 8;
      D.30466 = D.30204 + D.30465;
      tblock = *D.30466;
      D.30453 = tblock == 0B;
      D.30454 = (long int) D.30453;
      D.30455 = __builtin_expect (D.30454, 0);
      if (D.30455 != 0) goto <D.30467>; else goto <D.30468>;
      <D.30467>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.30468>:
      D.30458 = tblock->native_offset;
      D.30469 = D.30458 == 0;
      D.30470 = (long int) D.30469;
      D.30471 = __builtin_expect (D.30470, 0);
      if (D.30471 != 0) goto <D.30472>; else goto <D.30473>;
      <D.30472>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.30473>:
      D.30267 = cfg->native_code;
      D.30458 = tblock->native_offset;
      D.30459 = (sizetype) D.30458;
      D.30460 = D.30267 + D.30459;
      ei->try_start = D.30460;
      D.30474 = BIT_FIELD_REF <*tblock, 64, 1472>;
      D.30475 = D.30474 & 1099511627776;
      if (D.30475 != 0) goto <D.30476>; else goto <D.30477>;
      <D.30476>:
      D.30478 = ei->try_start;
      D.30479 = D.30478 + 18446744073709551615;
      ei->try_start = D.30479;
      <D.30477>:
      D.30204 = cfg->cil_offset_to_bb;
      D.30463 = ec->try_offset;
      D.30480 = ec->try_len;
      D.30481 = D.30463 + D.30480;
      D.30482 = (long unsigned int) D.30481;
      D.30483 = D.30482 * 8;
      D.30484 = D.30204 + D.30483;
      tblock = *D.30484;
      D.30453 = tblock == 0B;
      D.30454 = (long int) D.30453;
      D.30455 = __builtin_expect (D.30454, 0);
      if (D.30455 != 0) goto <D.30485>; else goto <D.30486>;
      <D.30485>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.30486>:
      D.30458 = tblock->native_offset;
      if (D.30458 == 0) goto <D.30487>; else goto <D.30488>;
      <D.30487>:
      {
        int j;
        int end;

        D.30463 = ec->try_offset;
        D.30480 = ec->try_len;
        D.30481 = D.30463 + D.30480;
        j = (int) D.30481;
        D.30463 = ec->try_offset;
        end = (int) D.30463;
        goto <D.26401>;
        <D.26400>:
        {
          struct MonoBasicBlock * bb;

          D.30204 = cfg->cil_offset_to_bb;
          D.30489 = (long unsigned int) j;
          D.30490 = D.30489 * 8;
          D.30491 = D.30204 + D.30490;
          bb = *D.30491;
          if (bb != 0B) goto <D.30492>; else goto <D.30493>;
          <D.30492>:
          D.30494 = bb->native_offset;
          if (D.30494 != 0) goto <D.30495>; else goto <D.30496>;
          <D.30495>:
          tblock = bb;
          goto <D.26399>;
          <D.30496>:
          <D.30493>:
        }
        j = j + -1;
        <D.26401>:
        if (j >= end) goto <D.26400>; else goto <D.26399>;
        <D.26399>:
      }
      <D.30488>:
      D.30267 = cfg->native_code;
      D.30458 = tblock->native_offset;
      D.30459 = (sizetype) D.30458;
      D.30460 = D.30267 + D.30459;
      ei->try_end = D.30460;
      D.30458 = tblock->native_offset;
      D.30469 = D.30458 == 0;
      D.30470 = (long int) D.30469;
      D.30471 = __builtin_expect (D.30470, 0);
      if (D.30471 != 0) goto <D.30497>; else goto <D.30498>;
      <D.30497>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.30498>:
      D.30204 = cfg->cil_offset_to_bb;
      D.30439 = ec->handler_offset;
      D.30499 = (long unsigned int) D.30439;
      D.30500 = D.30499 * 8;
      D.30501 = D.30204 + D.30500;
      tblock = *D.30501;
      D.30453 = tblock == 0B;
      D.30454 = (long int) D.30453;
      D.30455 = __builtin_expect (D.30454, 0);
      if (D.30455 != 0) goto <D.30502>; else goto <D.30503>;
      <D.30502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.30503>:
      D.30267 = cfg->native_code;
      D.30458 = tblock->native_offset;
      D.30459 = (sizetype) D.30458;
      D.30460 = D.30267 + D.30459;
      ei->handler_start = D.30460;
      tmp = cfg->try_block_holes;
      goto <D.26406>;
      <D.26405>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.30267 = cfg->native_code;
        D.30504 = hole->basic_block;
        D.30505 = D.30504->native_offset;
        D.30504 = hole->basic_block;
        D.30506 = D.30504->native_length;
        D.30507 = D.30505 + D.30506;
        D.30508 = (sizetype) D.30507;
        hole_end = D.30267 + D.30508;
        D.30509 = hole->clause;
        if (D.30509 == ec) goto <D.30510>; else goto <D.30511>;
        <D.30510>:
        D.30512 = ei->try_end;
        if (D.30512 == hole_end) goto <D.30513>; else goto <D.30514>;
        <D.30513>:
        D.30225 = cfg->verbose_level;
        D.30226 = D.30225 > 3;
        D.30227 = (long int) D.30226;
        D.30228 = __builtin_expect (D.30227, 0);
        if (D.30228 != 0) goto <D.30515>; else goto <D.30516>;
        <D.30515>:
        D.30512 = ei->try_end;
        D.30517 = (long int) D.30512;
        D.30267 = cfg->native_code;
        D.30518 = (long int) D.30267;
        D.30519 = D.30517 - D.30518;
        D.30520 = (int) D.30519;
        D.30521 = hole->start_offset;
        printf ("\tShortening try block %d from %x to %x\n", i, D.30520, D.30521);
        <D.30516>:
        D.30267 = cfg->native_code;
        D.30521 = hole->start_offset;
        D.30522 = (sizetype) D.30521;
        D.30523 = D.30267 + D.30522;
        ei->try_end = D.30523;
        goto <D.26404>;
        <D.30514>:
        <D.30511>:
      }
      tmp = tmp->next;
      <D.26406>:
      if (tmp != 0B) goto <D.26405>; else goto <D.26404>;
      <D.26404>:
      D.30438 = ec->flags;
      if (D.30438 == 2) goto <D.30524>; else goto <D.30525>;
      <D.30524>:
      {
        int end_offset;

        D.30439 = ec->handler_offset;
        D.30526 = ec->handler_len;
        D.30527 = D.30439 + D.30526;
        D.30528 = header->code_size;
        if (D.30527 < D.30528) goto <D.30529>; else goto <D.30530>;
        <D.30529>:
        D.30204 = cfg->cil_offset_to_bb;
        D.30439 = ec->handler_offset;
        D.30526 = ec->handler_len;
        D.30527 = D.30439 + D.30526;
        D.30531 = (long unsigned int) D.30527;
        D.30532 = D.30531 * 8;
        D.30533 = D.30204 + D.30532;
        tblock = *D.30533;
        D.30458 = tblock->native_offset;
        if (D.30458 != 0) goto <D.30534>; else goto <D.30535>;
        <D.30534>:
        end_offset = tblock->native_offset;
        goto <D.30536>;
        <D.30535>:
        {
          int j;
          int end;

          D.30439 = ec->handler_offset;
          D.30526 = ec->handler_len;
          D.30527 = D.30439 + D.30526;
          j = (int) D.30527;
          D.30439 = ec->handler_offset;
          end = (int) D.30439;
          goto <D.26413>;
          <D.26412>:
          {
            struct MonoBasicBlock * bb;

            D.30204 = cfg->cil_offset_to_bb;
            D.30537 = (long unsigned int) j;
            D.30538 = D.30537 * 8;
            D.30539 = D.30204 + D.30538;
            bb = *D.30539;
            if (bb != 0B) goto <D.30540>; else goto <D.30541>;
            <D.30540>:
            D.30542 = bb->native_offset;
            if (D.30542 != 0) goto <D.30543>; else goto <D.30544>;
            <D.30543>:
            tblock = bb;
            goto <D.26411>;
            <D.30544>:
            <D.30541>:
          }
          j = j + -1;
          <D.26413>:
          if (j >= end) goto <D.26412>; else goto <D.26411>;
          <D.26411>:
          D.30458 = tblock->native_offset;
          D.30545 = tblock->native_length;
          end_offset = D.30458 + D.30545;
        }
        <D.30536>:
        goto <D.30546>;
        <D.30530>:
        D.30547 = cfg->epilog_begin;
        end_offset = (int) D.30547;
        <D.30546>:
        D.30267 = cfg->native_code;
        D.30548 = (sizetype) end_offset;
        D.30549 = D.30267 + D.30548;
        ei->data.handler_end = D.30549;
      }
      <D.30525>:
    }
    i = i + 1;
    <D.26415>:
    D.30238 = header->num_clauses;
    D.30550 = (int) D.30238;
    if (D.30550 > i) goto <D.26414>; else goto <D.26416>;
    <D.26416>:
  }
  <D.30435>:
  <D.30431>:
  D.30225 = cfg->verbose_level;
  D.30226 = D.30225 > 3;
  D.30227 = (long int) D.30226;
  D.30228 = __builtin_expect (D.30227, 0);
  if (D.30228 != 0) goto <D.30551>; else goto <D.30552>;
  <D.30551>:
  {
    int i;

    i = 0;
    goto <D.26424>;
    <D.26423>:
    {
      struct MonoJitExceptionInfo * ei;
      int start;
      int end;
      int handler;
      int handler_end;

      ei = &jinfo->clauses[i];
      D.30553 = ei->try_start;
      D.30554 = (long int) D.30553;
      D.30267 = cfg->native_code;
      D.30518 = (long int) D.30267;
      D.30555 = D.30554 - D.30518;
      start = (int) D.30555;
      D.30556 = ei->try_end;
      D.30557 = (long int) D.30556;
      D.30267 = cfg->native_code;
      D.30518 = (long int) D.30267;
      D.30558 = D.30557 - D.30518;
      end = (int) D.30558;
      D.30559 = ei->handler_start;
      D.30560 = (long int) D.30559;
      D.30267 = cfg->native_code;
      D.30518 = (long int) D.30267;
      D.30561 = D.30560 - D.30518;
      handler = (int) D.30561;
      D.30562 = ei->data.handler_end;
      D.30563 = (long int) D.30562;
      D.30267 = cfg->native_code;
      D.30518 = (long int) D.30267;
      D.30564 = D.30563 - D.30518;
      handler_end = (int) D.30564;
      D.30565 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.30565, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.26424>:
    D.30566 = jinfo->num_clauses;
    D.30567 = (int) D.30566;
    if (D.30567 > i) goto <D.26423>; else goto <D.26425>;
    <D.26425>:
  }
  <D.30552>:
  D.30568 = cfg->encoded_unwind_ops;
  if (D.30568 != 0B) goto <D.30569>; else goto <D.30570>;
  <D.30569>:
  D.30568 = cfg->encoded_unwind_ops;
  D.30571 = cfg->encoded_unwind_ops_len;
  D.30572 = mono_cache_unwind_info (D.30568, D.30571);
  jinfo->used_regs = D.30572;
  D.30568 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.30568);
  goto <D.30573>;
  <D.30570>:
  D.30574 = cfg->unwind_ops;
  if (D.30574 != 0B) goto <D.30575>; else goto <D.30576>;
  <D.30575>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.30574 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.30574, &info_len);
        info_len.101 = info_len;
        D.30578 = mono_cache_unwind_info (unwind_info, info_len.101);
        jinfo->used_regs = D.30578;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.30576>:
  <D.30573>:
  D.30579 = jinfo;
  return D.30579;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.30581;
  unsigned int D.30584;
  long unsigned int D.30585;
  long unsigned int D.30586;
  long unsigned int D.30587;
  int D.30588;
  void * * D.30589;
  long unsigned int D.30590;
  long unsigned int D.30591;
  void * * D.30592;
  long int D.30593;
  int D.30594;
  long int D.30595;
  int D.30596;
  unsigned char D.30597;
  int D.30598;
  int D.30599;
  int D.30602;
  int D.30603;
  unsigned int i.102;
  long unsigned int D.30605;
  struct GSList * D.30606;
  long int D.30609;
  long int D.30611;
  int D.30616;
  long unsigned int D.30617;
  long unsigned int D.30618;
  struct GSList * * D.30619;
  struct GSList * D.30620;
  int D.30621;
  long unsigned int D.30622;
  void * D.30623;
  struct GSList * D.30624;
  struct MonoInst * D.30626;
  short unsigned int D.30629;
  struct GSList * D.30636;
  long int D.30639;
  int D.30646;
  long unsigned int D.30647;
  long unsigned int D.30648;
  struct GSList * * D.30649;
  struct GSList * D.30650;
  int D.30651;
  long unsigned int D.30652;
  void * D.30653;
  struct GSList * D.30654;
  unsigned int D.30655;
  struct GSList * * D.30658;
  struct GSList * D.30659;
  unsigned int D.30660;
  int D.30661;
  int D.30662;
  long unsigned int D.30663;
  long unsigned int D.30664;
  void * D.30665;
  int D.30670;
  void * D.30671;
  long int D.30672;
  int D.30673;
  int * D.30674;
  int j.103;
  long unsigned int D.30676;
  long unsigned int D.30677;
  int * D.30678;
  long unsigned int D.30679;
  long unsigned int D.30680;
  union mono_mutex_t * D.30683;
  _Bool D.30686;
  long int D.30687;
  long int D.30688;
  void * D.30691;
  struct GHashTable * D.30692;
  struct MonoMethod * D.30693;
  void * D.30694;
  _Bool D.30699;
  long int D.30700;
  long int D.30701;
  struct MonoBasicBlock * bb;
  struct GSList * bb_seq_points;
  struct GSList * l;
  struct MonoInst * last;
  struct MonoDomain * domain;
  int i;
  struct MonoSeqPointInfo * info;
  struct GSList * * next;

  domain = cfg->domain;
  D.30581 = cfg->seq_points;
  if (D.30581 == 0B) goto <D.30582>; else goto <D.30583>;
  <D.30582>:
  return;
  <D.30583>:
  D.30581 = cfg->seq_points;
  D.30584 = D.30581->len;
  D.30585 = (long unsigned int) D.30584;
  D.30586 = D.30585 * 32;
  D.30587 = D.30586 + 8;
  info = monoeg_malloc0 (D.30587);
  D.30581 = cfg->seq_points;
  D.30584 = D.30581->len;
  D.30588 = (int) D.30584;
  info->len = D.30588;
  i = 0;
  goto <D.26273>;
  <D.26272>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.30581 = cfg->seq_points;
    D.30589 = D.30581->pdata;
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30592 = D.30589 + D.30591;
    ins = *D.30592;
    D.30593 = ins->data.op[1].const_val;
    D.30594 = (int) D.30593;
    sp->il_offset = D.30594;
    D.30595 = ins->data.op[0].const_val;
    D.30596 = (int) D.30595;
    sp->native_offset = D.30596;
    D.30597 = ins->flags;
    D.30598 = (int) D.30597;
    D.30599 = D.30598 & 4;
    if (D.30599 != 0) goto <D.30600>; else goto <D.30601>;
    <D.30600>:
    D.30602 = sp->flags;
    D.30603 = D.30602 | 1;
    sp->flags = D.30603;
    <D.30601>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.26273>:
  D.30581 = cfg->seq_points;
  D.30584 = D.30581->len;
  i.102 = (unsigned int) i;
  if (D.30584 > i.102) goto <D.26272>; else goto <D.26274>;
  <D.26274>:
  D.30581 = cfg->seq_points;
  D.30584 = D.30581->len;
  D.30585 = (long unsigned int) D.30584;
  D.30605 = D.30585 * 8;
  next = monoeg_malloc0 (D.30605);
  bb = cfg->bb_entry;
  goto <D.26288>;
  <D.26287>:
  D.30606 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.30606);
  last = 0B;
  l = bb_seq_points;
  goto <D.26278>;
  <D.26277>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.30609 = ins->data.op[1].const_val;
    if (D.30609 == -1) goto <D.30607>; else goto <D.30610>;
    <D.30610>:
    D.30609 = ins->data.op[1].const_val;
    if (D.30609 == 16777215) goto <D.30607>; else goto <D.30608>;
    <D.30607>:
    // predicted unlikely by continue predictor.
    goto <D.26276>;
    <D.30608>:
    D.30611 = ins->data.op[0].const_val;
    if (D.30611 == -1) goto <D.30612>; else goto <D.30613>;
    <D.30612>:
    // predicted unlikely by continue predictor.
    goto <D.26276>;
    <D.30613>:
    if (last != 0B) goto <D.30614>; else goto <D.30615>;
    <D.30614>:
    D.30616 = last->backend.size;
    D.30617 = (long unsigned int) D.30616;
    D.30618 = D.30617 * 8;
    D.30619 = next + D.30618;
    D.30616 = last->backend.size;
    D.30617 = (long unsigned int) D.30616;
    D.30618 = D.30617 * 8;
    D.30619 = next + D.30618;
    D.30620 = *D.30619;
    D.30621 = ins->backend.size;
    D.30622 = (long unsigned int) D.30621;
    D.30623 = (void *) D.30622;
    D.30624 = monoeg_g_slist_append (D.30620, D.30623);
    *D.30619 = D.30624;
    goto <D.30625>;
    <D.30615>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.30625>:
    last = ins;
  }
  <D.26276>:
  l = l->next;
  <D.26278>:
  if (l != 0B) goto <D.26277>; else goto <D.26279>;
  <D.26279>:
  D.30626 = bb->last_ins;
  if (D.30626 != 0B) goto <D.30627>; else goto <D.30628>;
  <D.30627>:
  D.30626 = bb->last_ins;
  D.30629 = D.30626->opcode;
  if (D.30629 == 738) goto <D.30630>; else goto <D.30631>;
  <D.30630>:
  D.30606 = bb->seq_points;
  if (D.30606 != 0B) goto <D.30632>; else goto <D.30633>;
  <D.30632>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.30606 = bb->seq_points;
    l = monoeg_g_slist_last (D.30606);
    if (l != 0B) goto <D.30634>; else goto <D.30635>;
    <D.30634>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.26285>;
    <D.26284>:
    {
      struct GSList * l;

      D.30636 = bb2->seq_points;
      l = monoeg_g_slist_last (D.30636);
      if (l != 0B) goto <D.30637>; else goto <D.30638>;
      <D.30637>:
      {
        struct MonoInst * ins;

        ins = l->data;
        D.30639 = ins->data.op[1].const_val;
        if (D.30639 != -1) goto <D.30640>; else goto <D.30641>;
        <D.30640>:
        D.30639 = ins->data.op[1].const_val;
        if (D.30639 != 16777215) goto <D.30642>; else goto <D.30643>;
        <D.30642>:
        if (ins != endfinally_seq_point) goto <D.30644>; else goto <D.30645>;
        <D.30644>:
        D.30646 = endfinally_seq_point->backend.size;
        D.30647 = (long unsigned int) D.30646;
        D.30648 = D.30647 * 8;
        D.30649 = next + D.30648;
        D.30646 = endfinally_seq_point->backend.size;
        D.30647 = (long unsigned int) D.30646;
        D.30648 = D.30647 * 8;
        D.30649 = next + D.30648;
        D.30650 = *D.30649;
        D.30651 = ins->backend.size;
        D.30652 = (long unsigned int) D.30651;
        D.30653 = (void *) D.30652;
        D.30654 = monoeg_g_slist_append (D.30650, D.30653);
        *D.30649 = D.30654;
        <D.30645>:
        <D.30643>:
        <D.30641>:
      }
      <D.30638>:
    }
    bb2 = bb2->next_bb;
    <D.26285>:
    if (bb2 != 0B) goto <D.26284>; else goto <D.26286>;
    <D.26286>:
    <D.30635>:
  }
  <D.30633>:
  <D.30631>:
  <D.30628>:
  bb = bb->next_bb;
  <D.26288>:
  if (bb != 0B) goto <D.26287>; else goto <D.26289>;
  <D.26289>:
  D.30655 = cfg->verbose_level;
  if (D.30655 > 2) goto <D.30656>; else goto <D.30657>;
  <D.30656>:
  printf ("\nSEQ POINT MAP: \n");
  <D.30657>:
  i = 0;
  goto <D.26301>;
  <D.26300>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30658 = next + D.30591;
    D.30659 = *D.30658;
    D.30660 = monoeg_g_slist_length (D.30659);
    D.30661 = (int) D.30660;
    sp->next_len = D.30661;
    D.30662 = sp->next_len;
    D.30663 = (long unsigned int) D.30662;
    D.30664 = D.30663 * 4;
    D.30665 = monoeg_malloc (D.30664);
    sp->next = D.30665;
    j = 0;
    D.30655 = cfg->verbose_level;
    if (D.30655 > 2) goto <D.30666>; else goto <D.30667>;
    <D.30666>:
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30658 = next + D.30591;
    D.30659 = *D.30658;
    if (D.30659 != 0B) goto <D.30668>; else goto <D.30669>;
    <D.30668>:
    D.30670 = sp->il_offset;
    printf ("\tIL0x%x ->", D.30670);
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30658 = next + D.30591;
    l = *D.30658;
    goto <D.26295>;
    <D.26294>:
    D.30671 = l->data;
    D.30672 = (long int) D.30671;
    next_index = (int) D.30672;
    D.30673 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.30673);
    l = l->next;
    <D.26295>:
    if (l != 0B) goto <D.26294>; else goto <D.26296>;
    <D.26296>:
    printf ("\n");
    <D.30669>:
    <D.30667>:
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30658 = next + D.30591;
    l = *D.30658;
    goto <D.26298>;
    <D.26297>:
    D.30671 = l->data;
    D.30672 = (long int) D.30671;
    next_index = (int) D.30672;
    D.30674 = sp->next;
    j.103 = j;
    j = j.103 + 1;
    D.30676 = (long unsigned int) j.103;
    D.30677 = D.30676 * 4;
    D.30678 = D.30674 + D.30677;
    *D.30678 = next_index;
    l = l->next;
    <D.26298>:
    if (l != 0B) goto <D.26297>; else goto <D.26299>;
    <D.26299>:
    D.30590 = (long unsigned int) i;
    D.30591 = D.30590 * 8;
    D.30658 = next + D.30591;
    D.30659 = *D.30658;
    monoeg_g_slist_free (D.30659);
  }
  i = i + 1;
  <D.26301>:
  D.30581 = cfg->seq_points;
  D.30584 = D.30581->len;
  i.102 = (unsigned int) i;
  if (D.30584 > i.102) goto <D.26300>; else goto <D.26302>;
  <D.26302>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.30679 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30680 = D.30679 & 33554432;
  if (D.30680 == 0) goto <D.30681>; else goto <D.30682>;
  <D.30681>:
  {
    int ret;

    D.30683 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30683);
    if (ret != 0) goto <D.30684>; else goto <D.30685>;
    <D.30684>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30685>:
    D.30686 = ret != 0;
    D.30687 = (long int) D.30686;
    D.30688 = __builtin_expect (D.30687, 0);
    if (D.30688 != 0) goto <D.30689>; else goto <D.30690>;
    <D.30689>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.30690>:
  }
  D.30691 = domain->runtime_info;
  D.30692 = MEM[(struct MonoJitDomainInfo *)D.30691].seq_points;
  D.30693 = cfg->method_to_register;
  D.30694 = monoeg_g_hash_table_lookup (D.30692, D.30693);
  if (D.30694 == 0B) goto <D.30695>; else goto <D.30696>;
  <D.30695>:
  D.30691 = domain->runtime_info;
  D.30692 = MEM[(struct MonoJitDomainInfo *)D.30691].seq_points;
  D.30693 = cfg->method_to_register;
  monoeg_g_hash_table_insert_replace (D.30692, D.30693, info, 0);
  <D.30696>:
  {
    int ret;

    D.30683 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30683);
    if (ret != 0) goto <D.30697>; else goto <D.30698>;
    <D.30697>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30698>:
    D.30699 = ret != 0;
    D.30700 = (long int) D.30699;
    D.30701 = __builtin_expect (D.30700, 0);
    if (D.30701 != 0) goto <D.30702>; else goto <D.30703>;
    <D.30702>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.30703>:
  }
  <D.30682>:
  D.30581 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.30581, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.30705;
  long unsigned int D.30706;
  long unsigned int D.30707;
  struct MonoBasicBlock * * D.30708;
  struct MonoInst * D.30709;
  long unsigned int D.30712;
  long unsigned int D.30713;
  struct GSList * * D.30714;
  void * D.30715;
  long int D.30716;
  unsigned int D.30717;
  unsigned int dst_index.104;
  struct GSList * D.30722;
  long unsigned int D.30723;
  void * D.30724;
  struct GSList * D.30725;
  int D.30729;
  short int D.30730;
  int D.30731;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.26257>;
  <D.26256>:
  D.30705 = bb->in_bb;
  D.30706 = (long unsigned int) i;
  D.30707 = D.30706 * 8;
  D.30708 = D.30705 + D.30707;
  in_bb = *D.30708;
  D.30709 = in_bb->last_seq_point;
  if (D.30709 != 0B) goto <D.30710>; else goto <D.30711>;
  <D.30710>:
  {
    int src_index;
    int dst_index;

    D.30709 = in_bb->last_seq_point;
    src_index = D.30709->backend.size;
    dst_index = ins->backend.size;
    D.30712 = (long unsigned int) src_index;
    D.30713 = D.30712 * 8;
    D.30714 = next + D.30713;
    l = *D.30714;
    goto <D.26255>;
    <D.26254>:
    D.30715 = l->data;
    D.30716 = (long int) D.30715;
    D.30717 = (unsigned int) D.30716;
    dst_index.104 = (unsigned int) dst_index;
    if (D.30717 == dst_index.104) goto <D.26253>; else goto <D.30719>;
    <D.30719>:
    l = l->next;
    <D.26255>:
    if (l != 0B) goto <D.26254>; else goto <D.26253>;
    <D.26253>:
    if (l == 0B) goto <D.30720>; else goto <D.30721>;
    <D.30720>:
    D.30712 = (long unsigned int) src_index;
    D.30713 = D.30712 * 8;
    D.30714 = next + D.30713;
    D.30712 = (long unsigned int) src_index;
    D.30713 = D.30712 * 8;
    D.30714 = next + D.30713;
    D.30722 = *D.30714;
    D.30723 = (long unsigned int) dst_index;
    D.30724 = (void *) D.30723;
    D.30725 = monoeg_g_slist_append (D.30722, D.30724);
    *D.30714 = D.30725;
    <D.30721>:
  }
  goto <D.30726>;
  <D.30711>:
  if (depth <= 4) goto <D.30727>; else goto <D.30728>;
  <D.30727>:
  D.30729 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.30729);
  <D.30728>:
  <D.30726>:
  i = i + 1;
  <D.26257>:
  D.30730 = bb->in_count;
  D.30731 = (int) D.30730;
  if (D.30731 > i) goto <D.26256>; else goto <D.26258>;
  <D.26258>:
}


__attribute__((visibility ("hidden")))
mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.30732;
  struct MonoMethod * D.30733;
  long unsigned int D.30736;
  long unsigned int D.30737;
  int inited.105;
  int lookups.106;
  int lookups.107;
  int failed_lookups.108;
  int failed_lookups.109;
  struct MonoJitInfo * D.30749;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.30732 = &domain->jit_code_hash;
  D.30733 = mini_get_shared_method (method);
  ji = mono_internal_hash_table_lookup (D.30732, D.30733);
  if (ji != 0B) goto <D.30734>; else goto <D.30735>;
  <D.30734>:
  D.30736 = BIT_FIELD_REF <*ji, 64, 256>;
  D.30737 = D.30736 & 70368744177664;
  if (D.30737 == 0) goto <D.30738>; else goto <D.30739>;
  <D.30738>:
  ji = 0B;
  <D.30739>:
  <D.30735>:
  inited.105 = inited;
  if (inited.105 == 0) goto <D.30741>; else goto <D.30742>;
  <D.30741>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.30742>:
  lookups.106 = lookups;
  lookups.107 = lookups.106 + 1;
  lookups = lookups.107;
  if (ji == 0B) goto <D.30745>; else goto <D.30746>;
  <D.30745>:
  failed_lookups.108 = failed_lookups;
  failed_lookups.109 = failed_lookups.108 + 1;
  failed_lookups = failed_lookups.109;
  <D.30746>:
  D.30749 = ji;
  return D.30749;
}


__attribute__((visibility ("hidden")))
mono_enable_jit_map ()
{
  struct FILE * perf_map_file.110;
  int D.30754;
  struct FILE * D.30755;

  perf_map_file.110 = perf_map_file;
  if (perf_map_file.110 == 0B) goto <D.30752>; else goto <D.30753>;
  <D.30752>:
  {
    char name[64];

    try
      {
        D.30754 = getpid ();
        monoeg_g_snprintf (&name, 64, "/tmp/perf-%d.map", D.30754);
        unlink (&name);
        D.30755 = fopen (&name, "w");
        perf_map_file = D.30755;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.30753>:
}


__attribute__((visibility ("hidden")))
mono_emit_jit_tramp (void * start, int size, const char * desc)
{
  struct FILE * perf_map_file.111;
  long long unsigned int start.112;

  perf_map_file.111 = perf_map_file;
  if (perf_map_file.111 != 0B) goto <D.30757>; else goto <D.30758>;
  <D.30757>:
  perf_map_file.111 = perf_map_file;
  start.112 = (long long unsigned int) start;
  fprintf (perf_map_file.111, "%llx %x %s\n", start.112, size, desc);
  <D.30758>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.30760;

  D.30760 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.30760;
}


__attribute__((visibility ("hidden")))
mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.113;
  struct MonoMethod * D.30765;
  void * D.30766;
  int D.30767;

  perf_map_file.113 = perf_map_file;
  if (perf_map_file.113 != 0B) goto <D.30763>; else goto <D.30764>;
  <D.30763>:
  {
    char * name;

    D.30765 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.30765, 1);
    D.30766 = jinfo->code_start;
    D.30767 = jinfo->code_size;
    mono_emit_jit_tramp (D.30766, D.30767, name);
    monoeg_g_free (name);
  }
  <D.30764>:
}


__attribute__((visibility ("hidden")))
mono_jit_map_is_enabled ()
{
  gboolean D.30768;
  struct FILE * perf_map_file.114;
  _Bool D.30770;

  perf_map_file.114 = perf_map_file;
  D.30770 = perf_map_file.114 != 0B;
  D.30768 = (gboolean) D.30770;
  return D.30768;
}


__attribute__((visibility ("hidden")))
mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.115;
  unsigned int D.30773;
  struct MonoException * ex.116;
  _Bool D.30777;
  long int D.30778;
  long int D.30779;
  void * D.30782;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.115 = default_opt;
      D.30773 = mono_get_optimizations_for_method (method, default_opt.115);
      code = mono_jit_compile_method_with_opt (method, D.30773, &ex);
      if (code == 0B) goto <D.30774>; else goto <D.30775>;
      <D.30774>:
      ex.116 = ex;
      D.30777 = ex.116 == 0B;
      D.30778 = (long int) D.30777;
      D.30779 = __builtin_expect (D.30778, 0);
      if (D.30779 != 0) goto <D.30780>; else goto <D.30781>;
      <D.30780>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.30781>:
      ex.116 = ex;
      mono_raise_exception (ex.116);
      <D.30775>:
      D.30782 = code;
      return D.30782;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  long unsigned int D.30785;
  long unsigned int D.30786;
  <unnamed type> D.30791;
  void * D.30794;
  _Bool D.30795;
  long int D.30796;
  long int D.30797;
  long unsigned int D.30800;
  struct MonoClass * D.30805;
  struct MonoImage * D.30806;
  struct MonoImage * D.30807;
  long unsigned int D.30809;
  unsigned int D.30810;
  _Bool D.30816;
  long int D.30817;
  long int D.30818;
  <unnamed type> D.30821;
  long unsigned int D.30833;
  long unsigned int D.30834;
  int D.30835;
  int D.30836;
  _Bool D.30837;
  long int D.30838;
  long int D.30839;
  _Bool D.30842;
  int D.30843;
  void * D.30846;
  void * D.30847;
  int opt.117;
  struct MonoDomain * D.30854;
  _Bool D.30855;
  long int D.30856;
  long int D.30857;
  _Bool D.30864;
  long int D.30865;
  long int D.30866;
  const void * D.30869;
  _Bool D.30874;
  long int D.30875;
  long int D.30876;
  struct MonoDomain * target_domain;
  struct MonoDomain * domain;
  struct MonoJitInfo * info;
  void * code;
  void * p;
  struct MonoJitInfo * ji;
  struct MonoJitICallInfo * callinfo;
  struct WrapperInfo * winfo;

  domain = mono_domain_get ();
  callinfo = 0B;
  winfo = 0B;
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30786 = D.30785 & 4467570830351532032;
  if (D.30786 == 864691128455135232) goto <D.30787>; else goto <D.30788>;
  <D.30787>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.30788>:
  if (winfo != 0B) goto <D.30789>; else goto <D.30790>;
  <D.30789>:
  D.30791 = winfo->subtype;
  if (D.30791 == 15) goto <D.30792>; else goto <D.30793>;
  <D.30792>:
  D.30794 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.30794);
  D.30795 = callinfo == 0B;
  D.30796 = (long int) D.30795;
  D.30797 = __builtin_expect (D.30796, 0);
  if (D.30797 != 0) goto <D.30798>; else goto <D.30799>;
  <D.30798>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.30799>:
  opt = opt | 512;
  <D.30793>:
  <D.30790>:
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30800 = D.30785 & 18014398509481984;
  if (D.30800 != 0) goto <D.30801>; else goto <D.30802>;
  <D.30801>:
  opt = opt & 4294966783;
  <D.30802>:
  D.30805 = method->klass;
  D.30806 = D.30805->image;
  D.30807 = mono_get_corlib ();
  if (D.30806 != D.30807) goto <D.30803>; else goto <D.30808>;
  <D.30808>:
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30809 = D.30785 & 2251799813685248;
  if (D.30809 != 0) goto <D.30803>; else goto <D.30804>;
  <D.30803>:
  opt = opt & 4294966783;
  <D.30804>:
  D.30810 = opt & 512;
  if (D.30810 != 0) goto <D.30811>; else goto <D.30812>;
  <D.30811>:
  target_domain = mono_get_root_domain ();
  goto <D.30813>;
  <D.30812>:
  target_domain = domain;
  <D.30813>:
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30786 = D.30785 & 4467570830351532032;
  if (D.30786 == 3602879701896396800) goto <D.30814>; else goto <D.30815>;
  <D.30814>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.30816 = info == 0B;
    D.30817 = (long int) D.30816;
    D.30818 = __builtin_expect (D.30817, 0);
    if (D.30818 != 0) goto <D.30819>; else goto <D.30820>;
    <D.30819>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.30820>:
    D.30821 = info->subtype;
    if (D.30821 == 17) goto <D.30822>; else goto <D.30823>;
    <D.30822>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.30785 = BIT_FIELD_REF <*method, 64, 256>;
      D.30809 = D.30785 & 2251799813685248;
      if (D.30809 != 0) goto <D.30824>; else goto <D.30825>;
      <D.30824>:
      ctx = mono_method_get_context (method);
      <D.30825>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.30826>; else goto <D.30827>;
      <D.30826>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.30827>:
    }
    <D.30823>:
  }
  <D.30815>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.30828>; else goto <D.30829>;
  <D.30828>:
  if (domain == target_domain) goto <D.30830>; else goto <D.30832>;
  <D.30832>:
  D.30833 = BIT_FIELD_REF <*info, 64, 256>;
  D.30834 = D.30833 & 281474976710656;
  if (D.30834 != 0) goto <D.30830>; else goto <D.30831>;
  <D.30830>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.30835 = mono_jit_stats.methods_lookups;
    D.30836 = D.30835 + 1;
    mono_jit_stats.methods_lookups = D.30836;
    D.30805 = method->klass;
    vtable = mono_class_vtable (domain, D.30805);
    D.30837 = vtable == 0B;
    D.30838 = (long int) D.30837;
    D.30839 = __builtin_expect (D.30838, 0);
    if (D.30839 != 0) goto <D.30840>; else goto <D.30841>;
    <D.30840>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.30841>:
    D.30842 = ex == 0B;
    D.30843 = (int) D.30842;
    tmpEx = mono_runtime_class_init_full (vtable, D.30843);
    if (tmpEx != 0B) goto <D.30844>; else goto <D.30845>;
    <D.30844>:
    *ex = tmpEx;
    D.30846 = 0B;
    return D.30846;
    <D.30845>:
    D.30847 = info->code_start;
    D.30846 = mono_create_ftnptr (target_domain, D.30847);
    return D.30846;
  }
  <D.30831>:
  <D.30829>:
  opt.117 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.117, ex);
  if (code == 0B) goto <D.30849>; else goto <D.30850>;
  <D.30849>:
  D.30846 = 0B;
  return D.30846;
  <D.30850>:
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30786 = D.30785 & 4467570830351532032;
  if (D.30786 == 3458764513820540928) goto <D.30851>; else goto <D.30853>;
  <D.30853>:
  D.30785 = BIT_FIELD_REF <*method, 64, 256>;
  D.30786 = D.30785 & 4467570830351532032;
  if (D.30786 == 4035225266123964416) goto <D.30851>; else goto <D.30852>;
  <D.30851>:
  {
    struct MonoDomain * d;

    try
      {
        D.30854 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.30854, code, &d);
        D.30855 = ji == 0B;
        D.30856 = (long int) D.30855;
        D.30857 = __builtin_expect (D.30856, 0);
        if (D.30857 != 0) goto <D.30858>; else goto <D.30859>;
        <D.30858>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.30859>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.30852>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.30860>; else goto <D.30861>;
  <D.30860>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30862>; else goto <D.30863>;
    <D.30862>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30863>:
    D.30864 = ret != 0;
    D.30865 = (long int) D.30864;
    D.30866 = __builtin_expect (D.30865, 0);
    if (D.30866 != 0) goto <D.30867>; else goto <D.30868>;
    <D.30867>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6230, "ret == 0");
    <D.30868>:
  }
  D.30869 = callinfo->wrapper;
  if (D.30869 == 0B) goto <D.30870>; else goto <D.30871>;
  <D.30870>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.30871>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30872>; else goto <D.30873>;
    <D.30872>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30873>:
    D.30874 = ret != 0;
    D.30875 = (long int) D.30874;
    D.30876 = __builtin_expect (D.30875, 0);
    if (D.30876 != 0) goto <D.30877>; else goto <D.30878>;
    <D.30877>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.30878>:
  }
  mono_loader_unlock ();
  <D.30861>:
  D.30846 = p;
  return D.30846;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.30880;
  _Bool D.30883;
  long int D.30884;
  long int D.30885;
  _Bool D.30890;
  long int D.30891;
  long int D.30892;
  struct MonoJitInfo * D.30895;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.30880 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.30880);
    if (ret != 0) goto <D.30881>; else goto <D.30882>;
    <D.30881>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30882>:
    D.30883 = ret != 0;
    D.30884 = (long int) D.30883;
    D.30885 = __builtin_expect (D.30884, 0);
    if (D.30885 != 0) goto <D.30886>; else goto <D.30887>;
    <D.30886>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.30887>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.30880 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.30880);
    if (ret != 0) goto <D.30888>; else goto <D.30889>;
    <D.30888>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30889>:
    D.30890 = ret != 0;
    D.30891 = (long int) D.30890;
    D.30892 = __builtin_expect (D.30891, 0);
    if (D.30892 != 0) goto <D.30893>; else goto <D.30894>;
    <D.30893>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.30894>:
  }
  mono_loader_unlock ();
  D.30895 = info;
  return D.30895;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.30897;
  struct MonoJitInfo * D.30900;
  int D.30901;
  struct MonoJitInfo * ji;

  D.30897 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.30897, method);
  if (ji != 0B) goto <D.30898>; else goto <D.30899>;
  <D.30898>:
  D.30900 = ji;
  return D.30900;
  <D.30899>:
  D.30901 = mono_method_is_generic_sharable (method, 0);
  if (D.30901 == 0) goto <D.30902>; else goto <D.30903>;
  <D.30902>:
  D.30900 = 0B;
  return D.30900;
  <D.30903>:
  D.30900 = mono_domain_lookup_shared_generic (domain, method);
  return D.30900;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.30905;
  struct MonoMethod * method.118;
  struct MonoClass * D.30909;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  void * D.30917;
  short unsigned int D.30920;
  int D.30921;
  int D.30922;
  short unsigned int D.30924;
  int D.30925;
  int D.30926;
  void * D.30927;
  void * D.30932;
  int D.30934;
  char * D.30937;
  struct MonoImage * D.30938;
  char * D.30939;
  int check_for_pending_exc.119;
  void * D.30942;
  struct MonoDomain * D.30945;
  int D.30948;
  struct MonoClass * D.30951;
  struct MonoClass * D.30952;
  char D.30956;
  int D.30958;
  _Bool D.30960;
  long int D.30961;
  long int D.30962;
  const void * D.30965;
  int D.30968;
  int D.30972;
  void * D.30974;
  int D.30977;
  void * D.30980;
  struct MonoImage * D.30981;
  struct MonoException * D.30982;
  long unsigned int D.30983;
  long unsigned int D.30984;
  <unnamed type> D.30987;
  unsigned int D.30988;
  _Bool D.30991;
  struct MonoTrampInfo * in_tinfo.120;
  struct MonoTrampInfo * out_tinfo.121;
  int mono_aot_only.122;
  const char * iftmp.123;
  struct MonoTrampInfo * tinfo.124;
  struct MonoDomain * D.31010;
  struct MonoException * D.31016;
  unsigned int opt.125;
  double D.31018;
  double D.31019;
  double D.31020;
  unsigned int D.31021;
  void * D.31025;
  char * D.31031;
  guint32 * D.31045;
  struct MonoMethod * D.31046;
  void * * D.31047;
  struct MonoDomain * D.31048;
  unsigned int D.31051;
  unsigned int D.31052;
  union mono_mutex_t * D.31055;
  _Bool D.31058;
  long int D.31059;
  long int D.31060;
  union mono_mutex_t * D.31063;
  _Bool D.31066;
  long int D.31067;
  long int D.31068;
  struct MonoDomain * D.31075;
  long unsigned int D.31077;
  long unsigned int D.31078;
  struct MonoInternalHashTable * D.31081;
  struct MonoJitInfo * D.31082;
  struct MonoMethod * D.31083;
  _Bool D.31086;
  long int D.31087;
  long int D.31088;
  struct MonoGenericSharingContext * D.31091;
  int D.31094;
  long unsigned int D.31097;
  long unsigned int D.31098;
  int D.31099;
  long unsigned int D.31102;
  long unsigned int D.31103;
  _Bool D.31107;
  long int D.31108;
  long int D.31109;
  int D.31112;
  int D.31113;
  int D.31114;
  int D.31115;
  int D.31116;
  int D.31117;
  int D.31118;
  int D.31119;
  int D.31120;
  int D.31121;
  int D.31122;
  int D.31123;
  int D.31124;
  int D.31125;
  int D.31126;
  int D.31127;
  int D.31128;
  int D.31129;
  int D.31130;
  int D.31131;
  int D.31132;
  int D.31133;
  int D.31134;
  int D.31135;
  int D.31136;
  int D.31137;
  int D.31138;
  int D.31139;
  int D.31140;
  void * D.31141;
  struct GHashTable * D.31142;
  void * D.31147;
  _Bool D.31150;
  long int D.31151;
  long int D.31152;
  _Bool D.31157;
  long int D.31158;
  long int D.31159;
  unsigned int D.31162;
  struct MonoMethod * D.31167;
  struct MonoMethod * D.31170;
  struct MonoCompile * cfg;
  void * code;
  struct MonoJitInfo * jinfo;
  struct MonoJitInfo * info;
  struct MonoVTable * vtable;
  struct MonoException * ex;
  guint32 prof_options;
  struct GTimer * jit_timer;
  struct MonoMethod * prof_method;

  code = 0B;
  ex = 0B;
  D.30905 = opt & 65536;
  if (D.30905 != 0) goto <D.30906>; else goto <D.30907>;
  <D.30906>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.118 = method;
    D.30909 = method.118->klass;
    mono_class_init (D.30909);
    method.118 = method;
    code = mono_aot_get_method (domain, method.118);
    if (code != 0B) goto <D.30910>; else goto <D.30911>;
    <D.30910>:
    method.118 = method;
    D.30909 = method.118->klass;
    vtable = mono_class_vtable (domain, D.30909);
    D.30912 = vtable == 0B;
    D.30913 = (long int) D.30912;
    D.30914 = __builtin_expect (D.30913, 0);
    if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
    <D.30915>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.30916>:
    mono_runtime_class_init (vtable);
    D.30917 = code;
    return D.30917;
    <D.30911>:
  }
  <D.30907>:
  method.118 = method;
  D.30920 = method.118->iflags;
  D.30921 = (int) D.30920;
  D.30922 = D.30921 & 4096;
  if (D.30922 != 0) goto <D.30918>; else goto <D.30923>;
  <D.30923>:
  method.118 = method;
  D.30924 = method.118->flags;
  D.30925 = (int) D.30924;
  D.30926 = D.30925 & 8192;
  if (D.30926 != 0) goto <D.30918>; else goto <D.30919>;
  <D.30918>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.30927 = piinfo->addr;
    if (D.30927 == 0B) goto <D.30928>; else goto <D.30929>;
    <D.30928>:
    method.118 = method;
    D.30920 = method.118->iflags;
    D.30921 = (int) D.30920;
    D.30922 = D.30921 & 4096;
    if (D.30922 != 0) goto <D.30930>; else goto <D.30931>;
    <D.30930>:
    method.118 = method;
    D.30932 = mono_lookup_internal_call (method.118);
    piinfo->addr = D.30932;
    goto <D.30933>;
    <D.30931>:
    method.118 = method;
    D.30920 = method.118->iflags;
    D.30921 = (int) D.30920;
    D.30934 = D.30921 & 1;
    if (D.30934 != 0) goto <D.30935>; else goto <D.30936>;
    <D.30935>:
    method.118 = method;
    D.30937 = mono_method_full_name (method.118, 1);
    method.118 = method;
    D.30909 = method.118->klass;
    D.30938 = D.30909->image;
    D.30939 = D.30938->name;
    monoeg_g_log (0B, 16, "Method \'%s\' in assembly \'%s\' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", D.30937, D.30939);
    goto <D.30940>;
    <D.30936>:
    method.118 = method;
    mono_lookup_pinvoke_call (method.118, 0B, 0B);
    <D.30940>:
    <D.30933>:
    <D.30929>:
    method.118 = method;
    check_for_pending_exc.119 = check_for_pending_exc;
    nm = mono_marshal_get_native_wrapper (method.118, check_for_pending_exc.119, 0);
    D.30942 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.30942);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.30943>; else goto <D.30944>;
    <D.30943>:
    D.30945 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.30945, code);
    <D.30944>:
    if (jinfo != 0B) goto <D.30946>; else goto <D.30947>;
    <D.30946>:
    method.118 = method;
    mono_profiler_method_end_jit (method.118, jinfo, 0);
    <D.30947>:
    D.30917 = code;
    return D.30917;
  }
  <D.30919>:
  method.118 = method;
  D.30920 = method.118->iflags;
  D.30921 = (int) D.30920;
  D.30948 = D.30921 & 3;
  if (D.30948 != 0) goto <D.30949>; else goto <D.30950>;
  <D.30949>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.118 = method;
    name = method.118->name;
    method.118 = method;
    D.30909 = method.118->klass;
    D.30951 = D.30909->parent;
    D.30952 = mono_defaults.multicastdelegate_class;
    if (D.30951 == D.30952) goto <D.30953>; else goto <D.30954>;
    <D.30953>:
    D.30956 = *name;
    if (D.30956 == 46) goto <D.30957>; else goto <D.30955>;
    <D.30957>:
    D.30958 = strcmp (name, ".ctor");
    if (D.30958 == 0) goto <D.30959>; else goto <D.30955>;
    <D.30959>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.30960 = mi == 0B;
      D.30961 = (long int) D.30960;
      D.30962 = __builtin_expect (D.30961, 0);
      if (D.30962 != 0) goto <D.30963>; else goto <D.30964>;
      <D.30963>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.30964>:
      D.30965 = mono_icall_get_wrapper_full (mi, 1);
      D.30917 = mono_get_addr_from_ftnptr (D.30965);
      return D.30917;
    }
    <D.30955>:
    D.30956 = *name;
    if (D.30956 == 73) goto <D.30967>; else goto <D.30966>;
    <D.30967>:
    D.30968 = strcmp (name, "Invoke");
    if (D.30968 == 0) goto <D.30969>; else goto <D.30966>;
    <D.30969>:
    method.118 = method;
    D.30909 = method.118->klass;
    D.30917 = mono_create_delegate_trampoline (target_domain, D.30909);
    return D.30917;
    <D.30966>:
    D.30956 = *name;
    if (D.30956 == 66) goto <D.30971>; else goto <D.30970>;
    <D.30971>:
    D.30972 = strcmp (name, "BeginInvoke");
    if (D.30972 == 0) goto <D.30973>; else goto <D.30970>;
    <D.30973>:
    method.118 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.118);
    D.30974 = mono_compile_method (nm);
    D.30917 = mono_get_addr_from_ftnptr (D.30974);
    return D.30917;
    <D.30970>:
    D.30956 = *name;
    if (D.30956 == 69) goto <D.30975>; else goto <D.30976>;
    <D.30975>:
    D.30977 = strcmp (name, "EndInvoke");
    if (D.30977 == 0) goto <D.30978>; else goto <D.30979>;
    <D.30978>:
    method.118 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.118);
    D.30980 = mono_compile_method (nm);
    D.30917 = mono_get_addr_from_ftnptr (D.30980);
    return D.30917;
    <D.30979>:
    <D.30976>:
    <D.30954>:
    method.118 = method;
    full_name = mono_method_full_name (method.118, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.30981 = mono_defaults.corlib;
    D.30982 = mono_exception_from_name_msg (D.30981, "System", "InvalidProgramException", msg);
    *jit_ex = D.30982;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.30917 = 0B;
    return D.30917;
  }
  <D.30950>:
  method.118 = method;
  D.30983 = BIT_FIELD_REF <*method.118, 64, 256>;
  D.30984 = D.30983 & 4467570830351532032;
  if (D.30984 == 3602879701896396800) goto <D.30985>; else goto <D.30986>;
  <D.30985>:
  {
    struct WrapperInfo * info;

    method.118 = method;
    info = mono_marshal_get_wrapper_info (method.118);
    D.30987 = info->subtype;
    D.30988 = D.30987 + 4294967278;
    if (D.30988 <= 1) goto <D.30989>; else goto <D.30990>;
    <D.30989>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.30987 = info->subtype;
          D.30991 = D.30987 == 18;
          is_in = (gboolean) D.30991;
          if (is_in != 0) goto <D.30993>; else goto <D.30992>;
          <D.30993>:
          in_tinfo.120 = in_tinfo;
          if (in_tinfo.120 != 0B) goto <D.30995>; else goto <D.30992>;
          <D.30995>:
          in_tinfo.120 = in_tinfo;
          D.30917 = in_tinfo.120->code;
          return D.30917;
          <D.30992>:
          if (is_in == 0) goto <D.30996>; else goto <D.30997>;
          <D.30996>:
          out_tinfo.121 = out_tinfo;
          if (out_tinfo.121 != 0B) goto <D.30999>; else goto <D.31000>;
          <D.30999>:
          out_tinfo.121 = out_tinfo;
          D.30917 = out_tinfo.121->code;
          return D.30917;
          <D.31000>:
          <D.30997>:
          mono_aot_only.122 = mono_aot_only;
          if (mono_aot_only.122 != 0) goto <D.31002>; else goto <D.31003>;
          <D.31002>:
          if (is_in != 0) goto <D.31005>; else goto <D.31006>;
          <D.31005>:
          iftmp.123 = "gsharedvt_trampoline";
          goto <D.31007>;
          <D.31006>:
          iftmp.123 = "gsharedvt_out_trampoline";
          <D.31007>:
          mono_aot_get_trampoline_full (iftmp.123, &tinfo);
          goto <D.31008>;
          <D.31003>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.31008>:
          method.118 = method;
          tinfo.124 = tinfo;
          jinfo = create_jit_info_for_trampoline (method.118, tinfo.124);
          D.31010 = mono_get_root_domain ();
          mono_jit_info_table_add (D.31010, jinfo);
          if (is_in != 0) goto <D.31011>; else goto <D.31012>;
          <D.31011>:
          tinfo.124 = tinfo;
          in_tinfo = tinfo.124;
          goto <D.31013>;
          <D.31012>:
          tinfo.124 = tinfo;
          out_tinfo = tinfo.124;
          <D.31013>:
          tinfo.124 = tinfo;
          D.30917 = tinfo.124->code;
          return D.30917;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.30990>:
  }
  <D.30986>:
  mono_aot_only.122 = mono_aot_only;
  if (mono_aot_only.122 != 0) goto <D.31014>; else goto <D.31015>;
  <D.31014>:
  {
    char * fullname;
    char * msg;

    method.118 = method;
    fullname = mono_method_full_name (method.118, 1);
    msg = monoeg_g_strdup_printf ("Attempting to JIT compile method \'%s\' while running with --aot-only. See http://docs.xamarin.com/ios/about/limitations for more information.\n", fullname);
    D.31016 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.31016;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.30917 = 0B;
    return D.30917;
  }
  <D.31015>:
  jit_timer = monoeg_g_timer_new ();
  method.118 = method;
  opt.125 = (unsigned int) opt;
  cfg = mini_method_compile (method.118, opt.125, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.31018 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.31019 = mono_jit_stats.jit_time;
  D.31020 = D.31019 + D.31018;
  mono_jit_stats.jit_time = D.31020;
  monoeg_g_timer_destroy (jit_timer);
  D.31021 = cfg->exception_type;
  switch (D.31021) <default: <D.26671>, case 0: <D.26652>, case 1: <D.26664>, case 3: <D.26660>, case 4: <D.26661>, case 5: <D.26656>, case 6: <D.26655>, case 7: <D.26654>, case 8: <D.26657>, case 9: <D.26662>, case 10: <D.26663>, case 12: <D.26658>, case 13: <D.26668>, case 14: <D.26670>>
  <D.26652>:
  goto <D.26653>;
  <D.26654>:
  <D.26655>:
  <D.26656>:
  <D.26657>:
  <D.26658>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.31022>; else goto <D.31023>;
    <D.31022>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.31024>;
    <D.31023>:
    D.31025 = cfg->exception_ptr;
    if (D.31025 != 0B) goto <D.31026>; else goto <D.31027>;
    <D.31026>:
    D.31025 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.31025);
    goto <D.31028>;
    <D.31027>:
    D.31021 = cfg->exception_type;
    if (D.31021 == 6) goto <D.31029>; else goto <D.31030>;
    <D.31029>:
    D.30981 = mono_defaults.corlib;
    D.31031 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30981, "System", "MissingFieldException", D.31031);
    goto <D.31032>;
    <D.31030>:
    D.31021 = cfg->exception_type;
    if (D.31021 == 5) goto <D.31033>; else goto <D.31034>;
    <D.31033>:
    D.30981 = mono_defaults.corlib;
    D.31031 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30981, "System", "MissingMethodException", D.31031);
    goto <D.31035>;
    <D.31034>:
    D.31021 = cfg->exception_type;
    if (D.31021 == 7) goto <D.31036>; else goto <D.31037>;
    <D.31036>:
    D.30981 = mono_defaults.corlib;
    D.31031 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30981, "System", "TypeLoadException", D.31031);
    goto <D.31038>;
    <D.31037>:
    D.31021 = cfg->exception_type;
    if (D.31021 == 8) goto <D.31039>; else goto <D.31040>;
    <D.31039>:
    D.30981 = mono_defaults.corlib;
    D.31031 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.30981, "System", "FileNotFoundException", D.31031);
    goto <D.31041>;
    <D.31040>:
    D.31021 = cfg->exception_type;
    if (D.31021 == 12) goto <D.31042>; else goto <D.31043>;
    <D.31042>:
    D.31031 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.31031);
    goto <D.31044>;
    <D.31043>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.31044>:
    <D.31041>:
    <D.31038>:
    <D.31035>:
    <D.31032>:
    <D.31028>:
    <D.31024>:
    goto <D.26653>;
  }
  <D.26660>:
  D.30981 = mono_defaults.corlib;
  D.31031 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30981, "System", "InvalidProgramException", D.31031);
  goto <D.26653>;
  <D.26661>:
  D.30981 = mono_defaults.corlib;
  D.31031 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30981, "System.Security", "VerificationException", D.31031);
  goto <D.26653>;
  <D.26662>:
  D.30981 = mono_defaults.corlib;
  D.31031 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30981, "System", "MethodAccessException", D.31031);
  goto <D.26653>;
  <D.26663>:
  D.30981 = mono_defaults.corlib;
  D.31031 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.30981, "System", "FieldAccessException", D.31031);
  goto <D.26653>;
  <D.26664>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

    try
      {
        secman = mono_security_manager_get_methods ();
        exc = 0B;
        D.31045 = &cfg->exception_data;
        args[0] = D.31045;
        args[1] = &method;
        D.31046 = secman->linkdemandsecurityexception;
        mono_runtime_invoke (D.31046, 0B, &args, &exc);
        ex = exc;
        goto <D.26653>;
      }
    finally
      {
        exc = {CLOBBER};
        args = {CLOBBER};
      }
  }
  <D.26668>:
  {
    struct MonoException * exp;

    exp = cfg->exception_ptr;
    D.31047 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.31047);
    ex = exp;
    goto <D.26653>;
  }
  <D.26670>:
  D.31048 = mono_domain_get ();
  ex = D.31048->out_of_memory_ex;
  goto <D.26653>;
  <D.26671>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.26653>:
  if (ex != 0B) goto <D.31049>; else goto <D.31050>;
  <D.31049>:
  D.31051 = cfg->prof_options;
  D.31052 = D.31051 & 16;
  if (D.31052 != 0) goto <D.31053>; else goto <D.31054>;
  <D.31053>:
  method.118 = method;
  mono_profiler_method_end_jit (method.118, 0B, 1);
  <D.31054>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.30917 = 0B;
  return D.30917;
  <D.31050>:
  mono_loader_lock ();
  {
    int ret;

    D.31055 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.31055);
    if (ret != 0) goto <D.31056>; else goto <D.31057>;
    <D.31056>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31057>:
    D.31058 = ret != 0;
    D.31059 = (long int) D.31058;
    D.31060 = __builtin_expect (D.31059, 0);
    if (D.31060 != 0) goto <D.31061>; else goto <D.31062>;
    <D.31061>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.31062>:
  }
  {
    int ret;

    D.31063 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.31063);
    if (ret != 0) goto <D.31064>; else goto <D.31065>;
    <D.31064>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31065>:
    D.31066 = ret != 0;
    D.31067 = (long int) D.31066;
    D.31068 = __builtin_expect (D.31067, 0);
    if (D.31068 != 0) goto <D.31069>; else goto <D.31070>;
    <D.31069>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.31070>:
  }
  method.118 = method;
  info = lookup_method_inner (target_domain, method.118);
  if (info != 0B) goto <D.31071>; else goto <D.31072>;
  <D.31071>:
  D.31075 = mono_domain_get ();
  if (D.31075 == target_domain) goto <D.31073>; else goto <D.31076>;
  <D.31076>:
  D.31077 = BIT_FIELD_REF <*info, 64, 256>;
  D.31078 = D.31077 & 281474976710656;
  if (D.31078 != 0) goto <D.31073>; else goto <D.31074>;
  <D.31073>:
  code = info->code_start;
  <D.31074>:
  <D.31072>:
  if (code == 0B) goto <D.31079>; else goto <D.31080>;
  <D.31079>:
  D.31081 = &target_domain->jit_code_hash;
  D.31082 = cfg->jit_info;
  D.31083 = D.31082->d.method;
  D.31082 = cfg->jit_info;
  mono_internal_hash_table_insert (D.31081, D.31083, D.31082);
  {
    int ret;

    D.31063 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31063);
    if (ret != 0) goto <D.31084>; else goto <D.31085>;
    <D.31084>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31085>:
    D.31086 = ret != 0;
    D.31087 = (long int) D.31086;
    D.31088 = __builtin_expect (D.31087, 0);
    if (D.31088 != 0) goto <D.31089>; else goto <D.31090>;
    <D.31089>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.31090>:
  }
  code = cfg->native_code;
  D.31091 = cfg->generic_sharing_context;
  if (D.31091 != 0B) goto <D.31092>; else goto <D.31093>;
  <D.31092>:
  method.118 = method;
  D.31094 = mono_method_is_generic_sharable (method.118, 0);
  if (D.31094 != 0) goto <D.31095>; else goto <D.31096>;
  <D.31095>:
  D.31097 = mono_stats.generics_shared_methods;
  D.31098 = D.31097 + 1;
  mono_stats.generics_shared_methods = D.31098;
  <D.31096>:
  <D.31093>:
  D.31099 = cfg->gsharedvt;
  if (D.31099 != 0) goto <D.31100>; else goto <D.31101>;
  <D.31100>:
  D.31102 = mono_stats.gsharedvt_methods;
  D.31103 = D.31102 + 1;
  mono_stats.gsharedvt_methods = D.31103;
  <D.31101>:
  goto <D.31104>;
  <D.31080>:
  {
    int ret;

    D.31063 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31063);
    if (ret != 0) goto <D.31105>; else goto <D.31106>;
    <D.31105>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31106>:
    D.31107 = ret != 0;
    D.31108 = (long int) D.31107;
    D.31109 = __builtin_expect (D.31108, 0);
    if (D.31109 != 0) goto <D.31110>; else goto <D.31111>;
    <D.31110>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.31111>:
  }
  <D.31104>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.31112 = mono_jit_stats.allocate_var;
  D.31113 = cfg->stat_allocate_var;
  D.31114 = D.31112 + D.31113;
  mono_jit_stats.allocate_var = D.31114;
  D.31115 = mono_jit_stats.locals_stack_size;
  D.31116 = cfg->stat_locals_stack_size;
  D.31117 = D.31115 + D.31116;
  mono_jit_stats.locals_stack_size = D.31117;
  D.31118 = mono_jit_stats.basic_blocks;
  D.31119 = cfg->stat_basic_blocks;
  D.31120 = D.31118 + D.31119;
  mono_jit_stats.basic_blocks = D.31120;
  D.31121 = mono_jit_stats.max_basic_blocks;
  D.31119 = cfg->stat_basic_blocks;
  D.31122 = MAX_EXPR <D.31121, D.31119>;
  mono_jit_stats.max_basic_blocks = D.31122;
  D.31123 = mono_jit_stats.cil_code_size;
  D.31124 = cfg->stat_cil_code_size;
  D.31125 = D.31123 + D.31124;
  mono_jit_stats.cil_code_size = D.31125;
  D.31126 = mono_jit_stats.regvars;
  D.31127 = cfg->stat_n_regvars;
  D.31128 = D.31126 + D.31127;
  mono_jit_stats.regvars = D.31128;
  D.31129 = mono_jit_stats.inlineable_methods;
  D.31130 = cfg->stat_inlineable_methods;
  D.31131 = D.31129 + D.31130;
  mono_jit_stats.inlineable_methods = D.31131;
  D.31132 = mono_jit_stats.inlined_methods;
  D.31133 = cfg->stat_inlined_methods;
  D.31134 = D.31132 + D.31133;
  mono_jit_stats.inlined_methods = D.31134;
  D.31135 = mono_jit_stats.cas_demand_generation;
  D.31136 = cfg->stat_cas_demand_generation;
  D.31137 = D.31135 + D.31136;
  mono_jit_stats.cas_demand_generation = D.31137;
  D.31138 = mono_jit_stats.code_reallocs;
  D.31139 = cfg->stat_code_reallocs;
  D.31140 = D.31138 + D.31139;
  mono_jit_stats.code_reallocs = D.31140;
  mono_destroy_compile (cfg);
  D.31141 = target_domain->runtime_info;
  D.31142 = MEM[(struct MonoJitDomainInfo *)D.31141].jump_target_hash;
  if (D.31142 != 0B) goto <D.31143>; else goto <D.31144>;
  <D.31143>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        D.31141 = target_domain->runtime_info;
        D.31142 = MEM[(struct MonoJitDomainInfo *)D.31141].jump_target_hash;
        method.118 = method;
        jlist = monoeg_g_hash_table_lookup (D.31142, method.118);
        if (jlist != 0B) goto <D.31145>; else goto <D.31146>;
        <D.31145>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.118 = method;
        patch_info.data.method = method.118;
        D.31141 = target_domain->runtime_info;
        D.31142 = MEM[(struct MonoJitDomainInfo *)D.31141].jump_target_hash;
        method.118 = method;
        monoeg_g_hash_table_remove (D.31142, method.118);
        tmp = jlist->list;
        goto <D.26680>;
        <D.26679>:
        D.31147 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.31147, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.26680>:
        if (tmp != 0B) goto <D.26679>; else goto <D.26681>;
        <D.26681>:
        <D.31146>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.31144>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.31055 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31055);
    if (ret != 0) goto <D.31148>; else goto <D.31149>;
    <D.31148>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31149>:
    D.31150 = ret != 0;
    D.31151 = (long int) D.31150;
    D.31152 = __builtin_expect (D.31151, 0);
    if (D.31152 != 0) goto <D.31153>; else goto <D.31154>;
    <D.31153>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.31154>:
  }
  mono_loader_unlock ();
  method.118 = method;
  D.30909 = method.118->klass;
  vtable = mono_class_vtable (target_domain, D.30909);
  if (vtable == 0B) goto <D.31155>; else goto <D.31156>;
  <D.31155>:
  method.118 = method;
  D.30909 = method.118->klass;
  ex = mono_class_get_exception_for_failure (D.30909);
  D.31157 = ex == 0B;
  D.31158 = (long int) D.31157;
  D.31159 = __builtin_expect (D.31158, 0);
  if (D.31159 != 0) goto <D.31160>; else goto <D.31161>;
  <D.31160>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6115, "ex");
  <D.31161>:
  *jit_ex = ex;
  D.30917 = 0B;
  return D.30917;
  <D.31156>:
  D.31162 = prof_options & 16;
  if (D.31162 != 0) goto <D.31163>; else goto <D.31164>;
  <D.31163>:
  method.118 = method;
  D.30983 = BIT_FIELD_REF <*method.118, 64, 256>;
  D.30984 = D.30983 & 4467570830351532032;
  if (D.30984 == 864691128455135232) goto <D.31165>; else goto <D.31166>;
  <D.31165>:
  method.118 = method;
  D.31167 = mono_marshal_method_from_wrapper (method.118);
  if (D.31167 != 0B) goto <D.31168>; else goto <D.31169>;
  <D.31168>:
  method.118 = method;
  D.31170 = mono_marshal_method_from_wrapper (method.118);
  mono_profiler_method_end_jit (D.31170, jinfo, 0);
  <D.31169>:
  <D.31166>:
  method.118 = method;
  mono_profiler_method_end_jit (method.118, jinfo, 0);
  method.118 = method;
  if (prof_method != method.118) goto <D.31171>; else goto <D.31172>;
  <D.31171>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.31172>:
  <D.31164>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.31173>; else goto <D.31174>;
  <D.31173>:
  *jit_ex = ex;
  D.30917 = 0B;
  return D.30917;
  <D.31174>:
  D.30917 = code;
  return D.30917;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.31179;
  unsigned int info_len.126;
  struct GSList * D.31184;
  guint8 * D.31185;
  unsigned int D.31186;
  int D.31187;
  unsigned int info_len.127;
  unsigned int D.31189;
  struct MonoJitInfo * D.31190;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.31179 = info->uw_info;
      if (D.31179 != 0B) goto <D.31180>; else goto <D.31181>;
      <D.31180>:
      uw_info = info->uw_info;
      info_len.126 = info->uw_info_len;
      info_len = info_len.126;
      goto <D.31183>;
      <D.31181>:
      D.31184 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.31184, &info_len);
      <D.31183>:
      jinfo = mono_domain_alloc0 (domain, 48);
      jinfo->d.method = wrapper;
      D.31185 = info->code;
      jinfo->code_start = D.31185;
      D.31186 = info->code_size;
      D.31187 = (int) D.31186;
      jinfo->code_size = D.31187;
      info_len.127 = info_len;
      D.31189 = mono_cache_unwind_info (uw_info, info_len.127);
      jinfo->used_regs = D.31189;
      D.31190 = jinfo;
      return D.31190;
    }
  finally
    {
      info_len = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_jit_find_compiled_method_with_jit_info (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitInfo * * ji)
{
  unsigned int default_opt.128;
  unsigned int D.31194;
  long unsigned int D.31203;
  long unsigned int D.31204;
  int D.31205;
  int D.31206;
  void * D.31209;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.128 = default_opt;
  D.31194 = default_opt.128 & 512;
  if (D.31194 != 0) goto <D.31195>; else goto <D.31196>;
  <D.31195>:
  target_domain = mono_get_root_domain ();
  goto <D.31197>;
  <D.31196>:
  target_domain = domain;
  <D.31197>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.31198>; else goto <D.31199>;
  <D.31198>:
  if (domain == target_domain) goto <D.31200>; else goto <D.31202>;
  <D.31202>:
  D.31203 = BIT_FIELD_REF <*info, 64, 256>;
  D.31204 = D.31203 & 281474976710656;
  if (D.31204 != 0) goto <D.31200>; else goto <D.31201>;
  <D.31200>:
  D.31205 = mono_jit_stats.methods_lookups;
  D.31206 = D.31205 + 1;
  mono_jit_stats.methods_lookups = D.31206;
  if (ji != 0B) goto <D.31207>; else goto <D.31208>;
  <D.31207>:
  *ji = info;
  <D.31208>:
  D.31209 = info->code_start;
  return D.31209;
  <D.31201>:
  <D.31199>:
  if (ji != 0B) goto <D.31210>; else goto <D.31211>;
  <D.31210>:
  *ji = 0B;
  <D.31211>:
  D.31209 = 0B;
  return D.31209;
}


__attribute__((visibility ("hidden")))
mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.31213;
  long int D.31214;
  long int D.31215;
  int mono_do_single_method_regression.129;
  guint32 D.31221;
  struct MonoMethod * mono_current_single_method.130;
  struct GHashTable * mono_single_method_hash.131;
  struct GHashTable * D.31228;
  void * D.31229;
  struct GSList * mono_single_method_list.132;
  struct GSList * D.31233;

  D.31213 = method == 0B;
  D.31214 = (long int) D.31213;
  D.31215 = __builtin_expect (D.31214, 0);
  if (D.31215 != 0) goto <D.31216>; else goto <D.31217>;
  <D.31216>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.31217>:
  mono_do_single_method_regression.129 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.129 == 0) goto <D.31219>; else goto <D.31220>;
  <D.31219>:
  D.31221 = default_opt;
  return D.31221;
  <D.31220>:
  mono_current_single_method.130 = mono_current_single_method;
  if (mono_current_single_method.130 == 0B) goto <D.31223>; else goto <D.31224>;
  <D.31223>:
  mono_single_method_hash.131 = mono_single_method_hash;
  if (mono_single_method_hash.131 == 0B) goto <D.31226>; else goto <D.31227>;
  <D.31226>:
  D.31228 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = D.31228;
  <D.31227>:
  mono_single_method_hash.131 = mono_single_method_hash;
  D.31229 = monoeg_g_hash_table_lookup (mono_single_method_hash.131, method);
  if (D.31229 == 0B) goto <D.31230>; else goto <D.31231>;
  <D.31230>:
  mono_single_method_hash.131 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.131, method, method, 0);
  mono_single_method_list.132 = mono_single_method_list;
  D.31233 = monoeg_g_slist_prepend (mono_single_method_list.132, method);
  mono_single_method_list = D.31233;
  <D.31231>:
  D.31221 = default_opt;
  return D.31221;
  <D.31224>:
  mono_current_single_method.130 = mono_current_single_method;
  if (method == mono_current_single_method.130) goto <D.31234>; else goto <D.31235>;
  <D.31234>:
  D.31221 = mono_single_method_regression_opt;
  return D.31221;
  <D.31235>:
  D.31221 = default_opt;
  return D.31221;
}


__attribute__((visibility ("hidden")))
mono_jit_find_compiled_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.31237;

  D.31237 = mono_jit_find_compiled_method_with_jit_info (domain, method, 0B);
  return D.31237;
}


__attribute__((visibility ("hidden")))
mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoDomain * D.31239;
  void * D.31240;
  int D.31241;
  int D.31247;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.31239 = mono_domain_get ();
  D.31240 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.31239, D.31240);
  D.31241 = mono_arch_is_int_overflow (ctx, info);
  if (D.31241 != 0) goto <D.31242>; else goto <D.31243>;
  <D.31242>:
  exc = mono_get_exception_overflow ();
  goto <D.31244>;
  <D.31243>:
  exc = mono_get_exception_divide_by_zero ();
  <D.31244>:
  if (ji == 0B) goto <D.31245>; else goto <D.31246>;
  <D.31245>:
  D.31247 = mono_chain_signal (_dummy, info, context);
  if (D.31247 != 0) goto <D.31248>; else goto <D.31249>;
  <D.31248>:
  return;
  <D.31249>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31246>:
  mono_arch_handle_exception (ctx, exc);
}


__attribute__((visibility ("hidden")))
mono_sigill_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoException * exc;
  void * ctx;

  ctx = context;
  exc = mono_get_exception_execution_engine ("SIGILL");
  mono_arch_handle_exception (ctx, exc);
}


__attribute__((visibility ("hidden")))
mono_sigsegv_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  unsigned int mono_jit_tls_id.133;
  int D.31252;
  int D.31255;
  void * D.31258;
  int D.31259;
  struct MonoDomain * D.31264;
  int D.31266;
  struct MonoDomain * D.31269;
  void * D.31270;
  int D.31273;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.133 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.133);
  fault_addr = 0B;
  ctx = context;
  D.31252 = mono_arch_is_single_step_event (info, ctx);
  if (D.31252 != 0) goto <D.31253>; else goto <D.31254>;
  <D.31253>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.31254>:
  D.31255 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.31255 != 0) goto <D.31256>; else goto <D.31257>;
  <D.31256>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.31257>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.31258 = info->_sifields._sigfault.si_addr;
  D.31259 = mono_aot_is_pagefault (D.31258);
  if (D.31259 != 0) goto <D.31260>; else goto <D.31261>;
  <D.31260>:
  D.31258 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.31258);
  return;
  <D.31261>:
  D.31264 = mono_domain_get ();
  if (D.31264 == 0B) goto <D.31262>; else goto <D.31265>;
  <D.31265>:
  if (jit_tls == 0B) goto <D.31262>; else goto <D.31263>;
  <D.31262>:
  D.31266 = mono_chain_signal (_dummy, info, context);
  if (D.31266 != 0) goto <D.31267>; else goto <D.31268>;
  <D.31267>:
  return;
  <D.31268>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31263>:
  D.31269 = mono_domain_get ();
  D.31270 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.31269, D.31270);
  if (ji == 0B) goto <D.31271>; else goto <D.31272>;
  <D.31271>:
  D.31273 = mono_chain_signal (_dummy, info, context);
  if (D.31273 != 0) goto <D.31274>; else goto <D.31275>;
  <D.31274>:
  return;
  <D.31275>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31272>:
  mono_arch_handle_exception (ctx, 0B);
}


__attribute__((visibility ("hidden")))
mono_sigint_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoException * exc;
  void * ctx;

  ctx = context;
  exc = mono_get_exception_execution_engine ("Interrupted (SIGINT).");
  mono_arch_handle_exception (ctx, exc);
}


__attribute__((visibility ("hidden")))
mini_get_vtable_trampoline (int slot_index)
{
  _Bool D.31277;
  long int D.31278;
  long int D.31279;
  void * * vtable_trampolines.134;
  int D.31286;
  int vtable_trampolines_size.135;
  _Bool D.31290;
  long int D.31291;
  long int D.31292;
  int iftmp.136;
  long unsigned int D.31302;
  long unsigned int D.31303;
  long unsigned int D.31306;
  long unsigned int D.31307;
  _Bool D.31310;
  long int D.31311;
  long int D.31312;
  long unsigned int D.31315;
  long unsigned int D.31316;
  void * * D.31317;
  void * D.31318;
  long unsigned int D.31321;
  void * D.31322;
  struct MonoDomain * D.31323;
  void * D.31324;
  void * D.31325;
  int index;

  index = slot_index + 19;
  D.31277 = slot_index < -19;
  D.31278 = (long int) D.31277;
  D.31279 = __builtin_expect (D.31278, 0);
  if (D.31279 != 0) goto <D.31280>; else goto <D.31281>;
  <D.31280>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.31281>:
  vtable_trampolines.134 = vtable_trampolines;
  if (vtable_trampolines.134 == 0B) goto <D.31282>; else goto <D.31285>;
  <D.31285>:
  D.31286 = slot_index + 19;
  vtable_trampolines_size.135 = vtable_trampolines_size;
  if (D.31286 >= vtable_trampolines_size.135) goto <D.31282>; else goto <D.31283>;
  <D.31282>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31288>; else goto <D.31289>;
    <D.31288>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31289>:
    D.31290 = ret != 0;
    D.31291 = (long int) D.31290;
    D.31292 = __builtin_expect (D.31291, 0);
    if (D.31292 != 0) goto <D.31293>; else goto <D.31294>;
    <D.31293>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.31294>:
  }
  vtable_trampolines.134 = vtable_trampolines;
  if (vtable_trampolines.134 == 0B) goto <D.31295>; else goto <D.31297>;
  <D.31297>:
  vtable_trampolines_size.135 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.135) goto <D.31295>; else goto <D.31296>;
  <D.31295>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.135 = vtable_trampolines_size;
    if (vtable_trampolines_size.135 != 0) goto <D.31299>; else goto <D.31300>;
    <D.31299>:
    vtable_trampolines_size.135 = vtable_trampolines_size;
    iftmp.136 = vtable_trampolines_size.135 * 2;
    goto <D.31301>;
    <D.31300>:
    iftmp.136 = 128;
    <D.31301>:
    new_size = iftmp.136;
    goto <D.26831>;
    <D.26830>:
    new_size = new_size * 2;
    <D.26831>:
    if (new_size <= index) goto <D.26830>; else goto <D.26832>;
    <D.26832>:
    D.31302 = (long unsigned int) new_size;
    D.31303 = D.31302 * 8;
    new_table = monoeg_malloc0 (D.31303);
    vtable_trampolines.134 = vtable_trampolines;
    if (vtable_trampolines.134 != 0B) goto <D.31304>; else goto <D.31305>;
    <D.31304>:
    vtable_trampolines.134 = vtable_trampolines;
    vtable_trampolines_size.135 = vtable_trampolines_size;
    D.31306 = (long unsigned int) vtable_trampolines_size.135;
    D.31307 = D.31306 * 8;
    memcpy (new_table, vtable_trampolines.134, D.31307);
    <D.31305>:
    vtable_trampolines.134 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.134);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.31296>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31308>; else goto <D.31309>;
    <D.31308>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31309>:
    D.31310 = ret != 0;
    D.31311 = (long int) D.31310;
    D.31312 = __builtin_expect (D.31311, 0);
    if (D.31312 != 0) goto <D.31313>; else goto <D.31314>;
    <D.31313>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.31314>:
  }
  <D.31283>:
  vtable_trampolines.134 = vtable_trampolines;
  D.31315 = (long unsigned int) index;
  D.31316 = D.31315 * 8;
  D.31317 = vtable_trampolines.134 + D.31316;
  D.31318 = *D.31317;
  if (D.31318 == 0B) goto <D.31319>; else goto <D.31320>;
  <D.31319>:
  vtable_trampolines.134 = vtable_trampolines;
  D.31315 = (long unsigned int) index;
  D.31316 = D.31315 * 8;
  D.31317 = vtable_trampolines.134 + D.31316;
  D.31321 = (long unsigned int) slot_index;
  D.31322 = (void *) D.31321;
  D.31323 = mono_get_root_domain ();
  D.31324 = mono_create_specific_trampoline (D.31322, 12, D.31323, 0B);
  *D.31317 = D.31324;
  <D.31320>:
  vtable_trampolines.134 = vtable_trampolines;
  D.31315 = (long unsigned int) index;
  D.31316 = D.31315 * 8;
  D.31317 = vtable_trampolines.134 + D.31316;
  D.31325 = *D.31317;
  return D.31325;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
mini_get_debug_options ()
{
  struct MonoDebugOptions * D.31327;

  D.31327 = &debug_options;
  return D.31327;
}


__attribute__((visibility ("hidden")))
mini_init (const char * filename, const char * runtime_version)
{
  int D.31329;
  int default_opt_set.137;
  int D.31335;
  unsigned int D.31336;
  struct MonoCodeManager * global_codeman.138;
  struct MonoCodeManager * D.31340;
  struct GHashTable * D.31341;
  int mono_use_imt.139;
  const gchar * D.31345;
  const gchar * D.31348;
  struct MonoDebugOptions * D.31352;
  int D.31353;
  unsigned int default_opt.140;
  unsigned int D.31361;
  int D.31364;
  int mono_aot_only.141;
  struct MonoCodeManager * D.31373;
  void * D.31379;
  void * D.31380;
  void * D.31381;
  int mono_compile_aot.142;
  struct MonoDomain * D.31385;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.31329 = access ("/proc/self/maps", 0);
      if (D.31329 != 0) goto <D.31330>; else goto <D.31331>;
      <D.31330>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.31331>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.137 = default_opt_set;
      if (default_opt_set.137 == 0) goto <D.31333>; else goto <D.31334>;
      <D.31333>:
      D.31335 = mono_parse_default_optimizations (0B);
      D.31336 = (unsigned int) D.31335;
      default_opt = D.31336;
      <D.31334>:
      mono_runtime_set_has_tls_get (1);
      global_codeman.138 = global_codeman;
      if (global_codeman.138 == 0B) goto <D.31338>; else goto <D.31339>;
      <D.31338>:
      D.31340 = mono_code_manager_new ();
      global_codeman = D.31340;
      <D.31339>:
      D.31341 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
      jit_icall_name_hash = D.31341;
      memset (&callbacks, 0, 64);
      callbacks.create_ftnptr = mini_create_ftnptr;
      callbacks.get_addr_from_ftnptr = mini_get_addr_from_ftnptr;
      callbacks.get_runtime_build_info = mono_get_runtime_build_info;
      callbacks.set_cast_details = mono_set_cast_details;
      callbacks.debug_log = mono_debugger_agent_debug_log;
      callbacks.debug_log_is_enabled = mono_debugger_agent_debug_log_is_enabled;
      mono_use_imt.139 = mono_use_imt;
      if (mono_use_imt.139 != 0) goto <D.31343>; else goto <D.31344>;
      <D.31343>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.31344>:
      mono_install_callbacks (&callbacks);
      memset (&ticallbacks, 0, 24);
      ticallbacks.setup_async_callback = mono_setup_async_callback;
      ticallbacks.thread_state_init_from_sigctx = mono_thread_state_init_from_sigctx;
      ticallbacks.thread_state_init_from_handle = mono_thread_state_init_from_handle;
      mono_threads_runtime_init (&ticallbacks);
      D.31345 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.31345 != 0B) goto <D.31346>; else goto <D.31347>;
      <D.31346>:
      mini_parse_debug_options ();
      <D.31347>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.31348 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.31348 != 0B) goto <D.31349>; else goto <D.31350>;
      <D.31349>:
      {
        const char * xdebug_opts;

        xdebug_opts = monoeg_g_getenv ("MONO_XDEBUG");
        mono_xdebug_init (xdebug_opts);
        mono_dont_free_domains = 1;
        mono_using_xdebug = 1;
      }
      goto <D.31351>;
      <D.31350>:
      D.31352 = mini_get_debug_options ();
      D.31353 = D.31352->gdb;
      if (D.31353 != 0) goto <D.31354>; else goto <D.31355>;
      <D.31354>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.31355>:
      <D.31351>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.31356>; else goto <D.31357>;
      <D.31356>:
      if (0 != 0) goto <D.31358>; else goto <D.31359>;
      <D.31358>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.26911>:
      goto <D.26911>;
      <D.31359>:
      <D.31357>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.140 = default_opt;
      D.31361 = default_opt.140 & 65536;
      if (D.31361 != 0) goto <D.31362>; else goto <D.31363>;
      <D.31362>:
      mono_aot_init ();
      <D.31363>:
      mono_debugger_agent_init ();
      mono_set_generic_sharing_supported (1);
      mono_runtime_install_handlers ();
      mono_threads_install_cleanup (mini_thread_cleanup);
      mono_install_compile_method (mono_jit_compile_method);
      mono_install_free_method (mono_jit_free_method);
      mono_install_trampoline (mono_create_jit_trampoline);
      mono_install_jump_trampoline (mono_create_jump_trampoline);
      mono_install_remoting_trampoline (mono_jit_create_remoting_trampoline);
      mono_install_delegate_trampoline (mono_create_delegate_trampoline);
      mono_install_create_domain_hook (mini_create_jit_domain_info);
      mono_install_free_domain_hook (mini_free_jit_domain_info);
      mono_install_runtime_invoke (mono_jit_runtime_invoke);
      mono_install_get_cached_class_info (mono_aot_get_cached_class_info);
      mono_install_get_class_from_name (mono_aot_get_class_from_name);
      mono_install_jit_info_find_in_aot (mono_aot_find_jit_info);
      D.31364 = debug_options.collect_pagefault_stats;
      if (D.31364 != 0) goto <D.31365>; else goto <D.31366>;
      <D.31365>:
      mono_aot_set_make_unreadable (1);
      <D.31366>:
      if (runtime_version != 0B) goto <D.31367>; else goto <D.31368>;
      <D.31367>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.31369>;
      <D.31368>:
      domain = mono_init_from_assembly (filename, filename);
      <D.31369>:
      mono_aot_only.141 = mono_aot_only;
      if (mono_aot_only.141 != 0) goto <D.31371>; else goto <D.31372>;
      <D.31371>:
      D.31373 = domain->code_mp;
      mono_code_manager_set_read_only (D.31373);
      mono_marshal_use_aot_wrappers (1);
      <D.31372>:
      mono_use_imt.139 = mono_use_imt;
      if (mono_use_imt.139 != 0) goto <D.31374>; else goto <D.31375>;
      <D.31374>:
      mono_aot_only.141 = mono_aot_only;
      if (mono_aot_only.141 != 0) goto <D.31376>; else goto <D.31377>;
      <D.31376>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.31378>;
      <D.31377>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.31378>:
      <D.31375>:
      mono_arch_finish_init ();
      mono_icall_init ();
      mono_exceptions_init ();
      mini_gc_init ();
      mono_add_internal_call ("System.Diagnostics.StackFrame::get_frame_info", ves_icall_get_frame_info);
      mono_add_internal_call ("System.Diagnostics.StackTrace::get_trace", ves_icall_get_trace);
      mono_add_internal_call ("System.Exception::get_trace", ves_icall_System_Exception_get_trace);
      mono_add_internal_call ("System.Security.SecurityFrame::_GetSecurityFrame", ves_icall_System_Security_SecurityFrame_GetSecurityFrame);
      mono_add_internal_call ("System.Security.SecurityFrame::_GetSecurityStack", ves_icall_System_Security_SecurityFrame_GetSecurityStack);
      mono_add_internal_call ("Mono.Runtime::mono_runtime_install_handlers", mono_runtime_install_handlers);
      mono_create_helper_signatures ();
      register_jit_stats ();
      mono_marshal_init ();
      mono_arch_register_lowlevel_calls ();
      register_icall (mono_profiler_method_enter, "mono_profiler_method_enter", 0B, 1);
      register_icall (mono_profiler_method_leave, "mono_profiler_method_leave", 0B, 1);
      register_icall (mono_trace_enter_method, "mono_trace_enter_method", 0B, 1);
      register_icall (mono_trace_leave_method, "mono_trace_leave_method", 0B, 1);
      register_icall (mono_get_lmf_addr, "mono_get_lmf_addr", "ptr", 1);
      register_icall (mono_jit_thread_attach, "mono_jit_thread_attach", "ptr ptr", 1);
      register_icall (mono_jit_set_domain, "mono_jit_set_domain", "void ptr", 1);
      register_icall (mono_domain_get, "mono_domain_get", "ptr", 1);
      D.31379 = mono_get_throw_exception ();
      register_dyn_icall (D.31379, "mono_arch_throw_exception", "void object", 1);
      D.31380 = mono_get_rethrow_exception ();
      register_dyn_icall (D.31380, "mono_arch_rethrow_exception", "void object", 1);
      D.31381 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.31381, "mono_arch_throw_corlib_exception", "void ptr", 1);
      register_icall (mono_thread_get_undeniable_exception, "mono_thread_get_undeniable_exception", "object", 0);
      register_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", "void", 0);
      register_icall (mono_thread_force_interruption_checkpoint, "mono_thread_force_interruption_checkpoint", "void", 0);
      register_icall (mono_load_remote_field_new, "mono_load_remote_field_new", "object object ptr ptr", 0);
      register_icall (mono_store_remote_field_new, "mono_store_remote_field_new", "void object ptr ptr object", 0);
      register_opcode_emulation (684, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, "mono_fconv_u8", 0);
      register_opcode_emulation (683, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 0);
      register_opcode_emulation (712, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, "mono_fconv_ovf_i8", 0);
      register_opcode_emulation (713, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, "mono_fconv_ovf_u8", 0);
      register_opcode_emulation (536, "__emul_lconv_to_r8_un", "double long", mono_lconv_to_r8_un, "mono_lconv_to_r8_un", 0);
      register_opcode_emulation (727, "__emul_fconv_to_u", "ulong double", mono_fconv_u8, "mono_fconv_u8", 1);
      register_icall (mono_delegate_ctor, "mono_delegate_ctor", "void object object ptr", 0);
      register_icall (mono_class_static_field_address, "mono_class_static_field_address", "ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper, "mono_ldtoken_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper_generic_shared, "mono_ldtoken_wrapper_generic_shared", "ptr ptr ptr ptr", 0);
      register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", 0);
      register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", 0);
      register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", 0);
      register_icall (mono_object_new, "mono_object_new", "object ptr ptr", 0);
      register_icall (mono_object_new_specific, "mono_object_new_specific", "object ptr", 0);
      register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", 0);
      register_icall (mono_array_new_specific, "mono_array_new_specific", "object ptr int32", 0);
      register_icall (mono_runtime_class_init, "mono_runtime_class_init", "void ptr", 0);
      register_icall (mono_ldftn, "mono_ldftn", "ptr ptr", 0);
      register_icall (mono_ldvirtfn, "mono_ldvirtfn", "ptr object ptr", 0);
      register_icall (mono_ldvirtfn_gshared, "mono_ldvirtfn_gshared", "ptr object ptr", 0);
      register_icall (mono_helper_compile_generic_method, "mono_helper_compile_generic_method", "ptr object ptr ptr", 0);
      register_icall (mono_helper_ldstr, "mono_helper_ldstr", "object ptr int", 0);
      register_icall (mono_helper_ldstr_mscorlib, "mono_helper_ldstr_mscorlib", "object int", 0);
      register_icall (mono_helper_newobj_mscorlib, "mono_helper_newobj_mscorlib", "object int", 0);
      register_icall (mono_value_copy, "mono_value_copy", "void ptr ptr ptr", 0);
      register_icall (mono_object_castclass_unbox, "mono_object_castclass_unbox", "object object ptr", 0);
      register_icall (mono_break, "mono_break", 0B, 1);
      register_icall (mono_create_corlib_exception_0, "mono_create_corlib_exception_0", "object int", 1);
      register_icall (mono_create_corlib_exception_1, "mono_create_corlib_exception_1", "object int object", 1);
      register_icall (mono_create_corlib_exception_2, "mono_create_corlib_exception_2", "object int object object", 1);
      register_icall (mono_array_new_1, "mono_array_new_1", "object ptr int", 0);
      register_icall (mono_array_new_2, "mono_array_new_2", "object ptr int int", 0);
      register_icall (mono_array_new_3, "mono_array_new_3", "object ptr int int int", 0);
      register_icall (mono_array_new_4, "mono_array_new_4", "object ptr int int int int", 0);
      register_icall (mono_get_native_calli_wrapper, "mono_get_native_calli_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_resume_unwind, "mono_resume_unwind", "void", 1);
      register_icall (mono_gsharedvt_constrained_call, "mono_gsharedvt_constrained_call", "object ptr ptr ptr ptr ptr", 0);
      register_icall (mono_gsharedvt_value_copy, "mono_gsharedvt_value_copy", "void ptr ptr ptr", 1);
      register_icall (mono_gc_wbarrier_value_copy_bitmap, "mono_gc_wbarrier_value_copy_bitmap", "void ptr ptr int int", 0);
      register_icall (mono_object_castclass_with_cache, "mono_object_castclass_with_cache", "object object ptr ptr", 0);
      register_icall (mono_object_isinst_with_cache, "mono_object_isinst_with_cache", "object object ptr ptr", 0);
      register_icall (mono_debugger_agent_user_break, "mono_debugger_agent_user_break", "void", 0);
      mono_generic_sharing_init ();
      mono_compile_aot.142 = mono_compile_aot;
      if (mono_compile_aot.142 != 0) goto <D.31383>; else goto <D.31384>;
      <D.31383>:
      mono_runtime_set_no_exec (1);
      <D.31384>:
      mono_install_runtime_cleanup (mini_cleanup);
      mono_runtime_init (domain, mono_thread_start_cb, mono_thread_attach_cb);
      mono_thread_attach (domain);
      mono_profiler_runtime_initialized ();
      D.31385 = domain;
      return D.31385;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.31390;
  unsigned int D.31391;
  struct MonoInternalThread * thread;
  void * jit_tls;

  jit_tls = setup_jit_tls_data (stack_start, mono_thread_abort_dummy);
  thread = mono_thread_internal_current ();
  if (thread != 0B) goto <D.31388>; else goto <D.31389>;
  <D.31388>:
  thread->jit_data = jit_tls;
  <D.31389>:
  D.31390 = mono_profiler_get_events ();
  D.31391 = D.31390 & 32768;
  if (D.31391 != 0) goto <D.31392>; else goto <D.31393>;
  <D.31392>:
  mono_runtime_setup_stat_profiler ();
  <D.31393>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T37f3>) (struct MonoObject *) mono_thread_attach_aborted_cb.143;

  mono_thread_attach_aborted_cb.143 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.143 != 0B) goto <D.31395>; else goto <D.31396>;
  <D.31395>:
  mono_thread_attach_aborted_cb.143 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.143 (obj);
  goto <D.31397>;
  <D.31396>:
  mono_thread_abort (obj);
  <D.31397>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.31401;
  struct MonoVTable * D.31403;
  struct MonoClass * D.31404;
  struct MonoClass * D.31405;

  D.31401 = mono_runtime_unhandled_exception_policy_get ();
  if (D.31401 == 0) goto <D.31398>; else goto <D.31402>;
  <D.31402>:
  D.31403 = obj->vtable;
  D.31404 = D.31403->klass;
  D.31405 = mono_defaults.threadabortexception_class;
  if (D.31404 == D.31405) goto <D.31398>; else goto <D.31399>;
  <D.31398>:
  mono_thread_exit ();
  goto <D.31400>;
  <D.31399>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.31400>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.144;
  void * D.31409;
  void (*<T37f3>) (struct MonoObject *) abort_func.145;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.144 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.144);
  if (jit_tls != 0B) goto <D.31407>; else goto <D.31408>;
  <D.31407>:
  D.31409 = jit_tls;
  return D.31409;
  <D.31408>:
  jit_tls = monoeg_malloc0 (2720);
  abort_func.145 = (void (*<T37f3>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.145;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (344);
  lmf->ebp = 18446744073709551615;
  jit_tls->first_lmf = lmf;
  mono_lmf = lmf;
  mono_set_lmf_addr (&mono_lmf);
  mono_setup_altstack (jit_tls);
  D.31409 = jit_tls;
  return D.31409;
}


mono_set_jit_tls (struct MonoJitTlsData * jit_tls)
{
  unsigned int mono_jit_tls_id.146;

  mono_jit_tls_id.146 = mono_jit_tls_id;
  mono_native_tls_set_value (mono_jit_tls_id.146, jit_tls);
  mono_jit_tls = jit_tls;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.31413;
  int D.31414;
  _Bool D.31415;

  D.31414 = pthread_setspecific (key, value);
  D.31415 = D.31414 == 0;
  D.31413 = (int) D.31415;
  return D.31413;
}


mono_set_lmf_addr (void * lmf_addr)
{
  mono_lmf_addr = lmf_addr;
}


mono_thread_start_cb (intptr_t tid, void * stack_start, void * func)
{
  struct MonoInternalThread * thread;
  void * jit_tls;

  jit_tls = setup_jit_tls_data (stack_start, mono_thread_abort);
  thread = mono_thread_internal_current ();
  if (thread != 0B) goto <D.31417>; else goto <D.31418>;
  <D.31417>:
  thread->jit_data = jit_tls;
  <D.31418>:
  mono_arch_cpu_init ();
}


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  short unsigned int D.31421;
  int D.31422;
  int D.31423;
  long unsigned int D.31426;
  long unsigned int D.31427;
  struct MonoObject * D.31430;
  union mono_mutex_t * D.31431;
  _Bool D.31434;
  long int D.31435;
  long int D.31436;
  struct GHashTable * D.31439;
  _Bool D.31442;
  long int D.31443;
  long int D.31444;
  <unnamed type> D.31449;
  struct MonoClass * D.31452;
  unsigned char D.31453;
  struct MonoException * D.31458;
  struct MonoException * D.31460;
  struct MonoVTable * D.31461;
  struct MonoVTable * D.31462;
  _Bool D.31463;
  long int D.31464;
  long int D.31465;
  unsigned char D.31468;
  short unsigned int D.31471;
  unsigned int D.31472;
  unsigned int D.31473;
  int mono_aot_only.147;
  unsigned int default_opt.148;
  unsigned int D.31483;
  void * D.31484;
  void * D.31485;
  struct MonoException * jit_ex.149;
  _Bool D.31489;
  long int D.31490;
  long int D.31491;
  int D.31496;
  void * D.31497;
  struct MonoDynCallInfo * D.31499;
  void * D.31502;
  _Bool D.31505;
  long int D.31506;
  long int D.31507;
  _Bool D.31515;
  long int D.31516;
  long int D.31517;
  void * D.31520;
  struct MonoException * D.31523;
  struct MonoObject * D.31524;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T3463>) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;
  struct MonoDomain * domain;
  struct MonoJitDomainInfo * domain_info;
  struct RuntimeInvokeInfo * info;
  struct RuntimeInvokeInfo * info2;

  domain = mono_domain_get ();
  if (obj == 0B) goto <D.31419>; else goto <D.31420>;
  <D.31419>:
  D.31421 = method->flags;
  D.31422 = (int) D.31421;
  D.31423 = D.31422 & 16;
  if (D.31423 == 0) goto <D.31424>; else goto <D.31425>;
  <D.31424>:
  D.31426 = BIT_FIELD_REF <*method, 64, 256>;
  D.31427 = D.31426 & 4539628424389459968;
  if (D.31427 == 0) goto <D.31428>; else goto <D.31429>;
  <D.31428>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.31430 = 0B;
  return D.31430;
  <D.31429>:
  <D.31425>:
  <D.31420>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.31431 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31431);
    if (ret != 0) goto <D.31432>; else goto <D.31433>;
    <D.31432>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31433>:
    D.31434 = ret != 0;
    D.31435 = (long int) D.31434;
    D.31436 = __builtin_expect (D.31435, 0);
    if (D.31436 != 0) goto <D.31437>; else goto <D.31438>;
    <D.31437>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.31438>:
  }
  D.31439 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.31439, method);
  {
    int ret;

    D.31431 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31431);
    if (ret != 0) goto <D.31440>; else goto <D.31441>;
    <D.31440>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31441>:
    D.31442 = ret != 0;
    D.31443 = (long int) D.31442;
    D.31444 = __builtin_expect (D.31443, 0);
    if (D.31444 != 0) goto <D.31445>; else goto <D.31446>;
    <D.31445>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.31446>:
  }
  if (info == 0B) goto <D.31447>; else goto <D.31448>;
  <D.31447>:
  D.31449 = mono_security_get_mode ();
  if (D.31449 == 1) goto <D.31450>; else goto <D.31451>;
  <D.31450>:
  D.31452 = method->klass;
  mono_class_setup_vtable (D.31452);
  D.31452 = method->klass;
  D.31453 = D.31452->exception_type;
  if (D.31453 != 0) goto <D.31454>; else goto <D.31455>;
  <D.31454>:
  if (exc != 0B) goto <D.31456>; else goto <D.31457>;
  <D.31456>:
  D.31452 = method->klass;
  D.31458 = mono_class_get_exception_for_failure (D.31452);
  *exc = D.31458;
  goto <D.31459>;
  <D.31457>:
  D.31452 = method->klass;
  D.31460 = mono_class_get_exception_for_failure (D.31452);
  mono_raise_exception (D.31460);
  <D.31459>:
  D.31430 = 0B;
  return D.31430;
  <D.31455>:
  <D.31451>:
  info = monoeg_malloc0 (48);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.31452 = method->klass;
  D.31461 = mono_class_vtable_full (domain, D.31452, 1);
  info->vtable = D.31461;
  D.31462 = info->vtable;
  D.31463 = D.31462 == 0B;
  D.31464 = (long int) D.31463;
  D.31465 = __builtin_expect (D.31464, 0);
  if (D.31465 != 0) goto <D.31466>; else goto <D.31467>;
  <D.31466>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.31467>:
  callee = method;
  D.31452 = method->klass;
  D.31468 = D.31452->rank;
  if (D.31468 != 0) goto <D.31469>; else goto <D.31470>;
  <D.31469>:
  D.31471 = method->iflags;
  D.31472 = (unsigned int) D.31471;
  D.31473 = D.31472 & 4097;
  if (D.31473 == 4097) goto <D.31474>; else goto <D.31475>;
  <D.31474>:
  mono_aot_only.147 = mono_aot_only;
  if (mono_aot_only.147 != 0) goto <D.31477>; else goto <D.31478>;
  <D.31477>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.31479>;
  <D.31478>:
  callee = 0B;
  <D.31479>:
  <D.31475>:
  <D.31470>:
  if (callee != 0B) goto <D.31480>; else goto <D.31481>;
  <D.31480>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.148 = default_opt;
        D.31483 = mono_get_optimizations_for_method (callee, default_opt.148);
        D.31484 = mono_jit_compile_method_with_opt (callee, D.31483, &jit_ex);
        info->compiled_method = D.31484;
        D.31485 = info->compiled_method;
        if (D.31485 == 0B) goto <D.31486>; else goto <D.31487>;
        <D.31486>:
        monoeg_g_free (info);
        jit_ex.149 = jit_ex;
        D.31489 = jit_ex.149 == 0B;
        D.31490 = (long int) D.31489;
        D.31491 = __builtin_expect (D.31490, 0);
        if (D.31491 != 0) goto <D.31492>; else goto <D.31493>;
        <D.31492>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.31493>:
        if (exc != 0B) goto <D.31494>; else goto <D.31495>;
        <D.31494>:
        jit_ex.149 = jit_ex;
        *exc = jit_ex.149;
        D.31430 = 0B;
        return D.31430;
        <D.31495>:
        jit_ex.149 = jit_ex;
        mono_raise_exception (jit_ex.149);
        <D.31487>:
        D.31485 = info->compiled_method;
        D.31496 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.31497 = mini_add_method_trampoline (0B, callee, D.31485, D.31496, 0);
        info->compiled_method = D.31497;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.31498>;
  <D.31481>:
  info->compiled_method = 0B;
  <D.31498>:
  D.31499 = info->dyn_call_info;
  if (D.31499 == 0B) goto <D.31500>; else goto <D.31501>;
  <D.31500>:
  D.31502 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.31502;
  <D.31501>:
  {
    int ret;

    D.31431 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31431);
    if (ret != 0) goto <D.31503>; else goto <D.31504>;
    <D.31503>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31504>:
    D.31505 = ret != 0;
    D.31506 = (long int) D.31505;
    D.31507 = __builtin_expect (D.31506, 0);
    if (D.31507 != 0) goto <D.31508>; else goto <D.31509>;
    <D.31508>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.31509>:
  }
  D.31439 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.31439, method);
  if (info2 != 0B) goto <D.31510>; else goto <D.31511>;
  <D.31510>:
  monoeg_g_free (info);
  info = info2;
  goto <D.31512>;
  <D.31511>:
  D.31439 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.31439, method, info, 0);
  <D.31512>:
  {
    int ret;

    D.31431 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31431);
    if (ret != 0) goto <D.31513>; else goto <D.31514>;
    <D.31513>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31514>:
    D.31515 = ret != 0;
    D.31516 = (long int) D.31515;
    D.31517 = __builtin_expect (D.31516, 0);
    if (D.31517 != 0) goto <D.31518>; else goto <D.31519>;
    <D.31518>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6587, "ret == 0");
    <D.31519>:
  }
  <D.31448>:
  D.31520 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T3463>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.31520;
  if (exc != 0B) goto <D.31521>; else goto <D.31522>;
  <D.31521>:
  D.31462 = info->vtable;
  D.31523 = mono_runtime_class_init_full (D.31462, 0);
  *exc = D.31523;
  D.31524 = *exc;
  if (D.31524 != 0B) goto <D.31525>; else goto <D.31526>;
  <D.31525>:
  D.31430 = 0B;
  return D.31430;
  <D.31526>:
  goto <D.31527>;
  <D.31522>:
  D.31462 = info->vtable;
  mono_runtime_class_init (D.31462);
  <D.31527>:
  if (exc != 0B) goto <D.31528>; else goto <D.31529>;
  <D.31528>:
  *exc = 0B;
  <D.31529>:
  D.31485 = info->compiled_method;
  D.31430 = runtime_invoke (obj, params, exc, D.31485);
  return D.31430;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31533;
  struct GHashTable * D.31534;
  struct GHashTable * D.31537;
  struct GHashTable * D.31540;
  struct GHashTable * D.31543;
  struct GHashTable * D.31544;
  struct GHashTable * D.31545;
  struct GHashTable * D.31546;
  struct GHashTable * D.31547;
  struct GHashTable * D.31550;
  struct GHashTable * D.31551;
  struct GHashTable * D.31552;
  struct GHashTable * D.31553;
  void * D.31554;
  struct GHashTable * D.31557;
  void * D.31560;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.31533 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.31533, delete_jump_list, 0B);
  D.31533 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.31533);
  D.31534 = info->jump_target_got_slot_hash;
  if (D.31534 != 0B) goto <D.31535>; else goto <D.31536>;
  <D.31535>:
  D.31534 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.31534, delete_got_slot_list, 0B);
  D.31534 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.31534);
  <D.31536>:
  D.31537 = info->dynamic_code_hash;
  if (D.31537 != 0B) goto <D.31538>; else goto <D.31539>;
  <D.31538>:
  D.31537 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.31537, dynamic_method_info_free, 0B);
  D.31537 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.31537);
  <D.31539>:
  D.31540 = info->method_code_hash;
  if (D.31540 != 0B) goto <D.31541>; else goto <D.31542>;
  <D.31541>:
  D.31540 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.31540);
  <D.31542>:
  D.31543 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31543);
  D.31544 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31544);
  D.31545 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31545);
  D.31546 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31546);
  D.31547 = info->static_rgctx_trampoline_hash;
  if (D.31547 != 0B) goto <D.31548>; else goto <D.31549>;
  <D.31548>:
  D.31547 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31547);
  <D.31549>:
  D.31550 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31550);
  D.31551 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.31551);
  D.31552 = info->seq_points;
  monoeg_g_hash_table_destroy (D.31552);
  D.31553 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.31553);
  D.31554 = info->agent_info;
  if (D.31554 != 0B) goto <D.31555>; else goto <D.31556>;
  <D.31555>:
  mono_debugger_agent_free_domain_info (domain);
  <D.31556>:
  D.31557 = info->gsharedvt_arg_tramp_hash;
  if (D.31557 != 0B) goto <D.31558>; else goto <D.31559>;
  <D.31558>:
  D.31557 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.31557);
  <D.31559>:
  D.31560 = domain->runtime_info;
  monoeg_g_free (D.31560);
  domain->runtime_info = 0B;
}


dynamic_method_info_free (void * key, void * value, void * user_data)
{
  struct MonoCodeManager * D.31561;
  struct MonoJitDynamicMethodInfo * di;

  di = value;
  D.31561 = di->code_mp;
  mono_code_manager_destroy (D.31561);
  monoeg_g_free (di);
}


delete_got_slot_list (void * key, void * value, void * user_data)
{
  struct GSList * list;

  list = value;
  monoeg_g_slist_free (list);
}


delete_jump_list (void * key, void * value, void * user_data)
{
  struct GSList * D.31562;
  struct MonoJumpList * jlist;

  jlist = value;
  D.31562 = jlist->list;
  monoeg_g_slist_free (D.31562);
}


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31563;
  struct GHashTable * D.31564;
  struct GHashTable * D.31565;
  struct GHashTable * D.31566;
  struct GHashTable * D.31567;
  struct GHashTable * D.31568;
  struct GHashTable * D.31569;
  struct GHashTable * D.31570;
  struct GHashTable * D.31571;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (392);
  D.31563 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.31563;
  D.31564 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.31564;
  D.31565 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.31565;
  D.31566 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.31566;
  D.31567 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.31567;
  D.31568 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.31568;
  D.31569 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.31569;
  D.31570 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.31570;
  D.31571 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.31571;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.31572;
  int D.31573;
  int i;
  struct MonoSeqPointInfo * info;

  i = 0;
  info = value;
  i = 0;
  goto <D.26897>;
  <D.26896>:
  {
    struct SeqPoint * sp;

    sp = &info->seq_points[i];
    D.31572 = sp->next;
    monoeg_g_free (D.31572);
  }
  i = i + 1;
  <D.26897>:
  D.31573 = info->len;
  if (D.31573 > i) goto <D.26896>; else goto <D.26898>;
  <D.26898>:
  monoeg_g_free (info);
}


runtime_invoke_info_free (void * value)
{
  struct RuntimeInvokeInfo * info;

  info = value;
  monoeg_g_free (info);
}


mono_jit_create_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  short unsigned int D.31574;
  int D.31575;
  int D.31576;
  struct MonoMethodSignature * D.31579;
  short unsigned int D.31580;
  void * D.31583;
  int D.31587;
  struct MonoMethodSignature * D.31589;
  long unsigned int D.31590;
  long unsigned int D.31591;
  struct MonoClass * D.31593;
  long unsigned int D.31594;
  long unsigned int D.31595;
  struct MonoClass * D.31597;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.31574 = method->flags;
  D.31575 = (int) D.31574;
  D.31576 = D.31575 & 64;
  if (D.31576 != 0) goto <D.31577>; else goto <D.31578>;
  <D.31577>:
  D.31579 = mono_method_signature (method);
  D.31580 = D.31579->generic_param_count;
  if (D.31580 != 0) goto <D.31581>; else goto <D.31582>;
  <D.31581>:
  D.31583 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.31583;
  <D.31582>:
  <D.31578>:
  D.31574 = method->flags;
  D.31575 = (int) D.31574;
  D.31587 = D.31575 & 1024;
  if (D.31587 != 0) goto <D.31584>; else goto <D.31588>;
  <D.31588>:
  D.31589 = mono_method_signature (method);
  D.31590 = BIT_FIELD_REF <*D.31589, 64, 64>;
  D.31591 = D.31590 & 512;
  if (D.31591 != 0) goto <D.31592>; else goto <D.31585>;
  <D.31592>:
  D.31593 = method->klass;
  D.31594 = BIT_FIELD_REF <*D.31593, 64, 256>;
  D.31595 = D.31594 & 2199023255552;
  if (D.31595 != 0) goto <D.31584>; else goto <D.31596>;
  <D.31596>:
  D.31593 = method->klass;
  D.31597 = mono_defaults.object_class;
  if (D.31593 == D.31597) goto <D.31584>; else goto <D.31585>;
  <D.31584>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.31586>;
  <D.31585>:
  addr = mono_compile_method (method);
  <D.31586>:
  D.31583 = mono_get_addr_from_ftnptr (addr);
  return D.31583;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  long unsigned int D.31599;
  long unsigned int D.31600;
  _Bool D.31601;
  long int D.31602;
  long int D.31603;
  union mono_mutex_t * D.31606;
  _Bool D.31609;
  long int D.31610;
  long int D.31611;
  _Bool D.31616;
  long int D.31617;
  long int D.31618;
  _Bool D.31625;
  long int D.31626;
  long int D.31627;
  void * D.31630;
  struct GHashTable * D.31631;
  struct MonoInternalHashTable * D.31632;
  struct GHashTable * D.31633;
  struct GHashTable * D.31634;
  struct GHashTable * D.31635;
  struct MonoJumpList * jlist.150;
  struct MonoJitInfo * D.31637;
  void * D.31638;
  int D.31641;
  sizetype D.31642;
  guint8 * D.31643;
  struct GSList * D.31646;
  void * D.31647;
  struct GSList * D.31648;
  int D.31649;
  _Bool D.31652;
  long int D.31653;
  long int D.31654;
  struct MonoCodeManager * D.31659;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.31599 = BIT_FIELD_REF <*method, 64, 256>;
      D.31600 = D.31599 & 18014398509481984;
      D.31601 = D.31600 == 0;
      D.31602 = (long int) D.31601;
      D.31603 = __builtin_expect (D.31602, 0);
      if (D.31603 != 0) goto <D.31604>; else goto <D.31605>;
      <D.31604>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.31605>:
      {
        int ret;

        D.31606 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31606);
        if (ret != 0) goto <D.31607>; else goto <D.31608>;
        <D.31607>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31608>:
        D.31609 = ret != 0;
        D.31610 = (long int) D.31609;
        D.31611 = __builtin_expect (D.31610, 0);
        if (D.31611 != 0) goto <D.31612>; else goto <D.31613>;
        <D.31612>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.31613>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.31606 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31606);
        if (ret != 0) goto <D.31614>; else goto <D.31615>;
        <D.31614>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31615>:
        D.31616 = ret != 0;
        D.31617 = (long int) D.31616;
        D.31618 = __builtin_expect (D.31617, 0);
        if (D.31618 != 0) goto <D.31619>; else goto <D.31620>;
        <D.31619>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.31620>:
      }
      if (ji == 0B) goto <D.31621>; else goto <D.31622>;
      <D.31621>:
      return;
      <D.31622>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.31606 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31606);
        if (ret != 0) goto <D.31623>; else goto <D.31624>;
        <D.31623>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31624>:
        D.31625 = ret != 0;
        D.31626 = (long int) D.31625;
        D.31627 = __builtin_expect (D.31626, 0);
        if (D.31627 != 0) goto <D.31628>; else goto <D.31629>;
        <D.31628>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.31629>:
      }
      D.31630 = domain->runtime_info;
      D.31631 = MEM[(struct MonoJitDomainInfo *)D.31630].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.31631, method);
      D.31632 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.31632, method);
      D.31630 = domain->runtime_info;
      D.31633 = MEM[(struct MonoJitDomainInfo *)D.31630].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.31633, method);
      D.31630 = domain->runtime_info;
      D.31634 = MEM[(struct MonoJitDomainInfo *)D.31630].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.31634, method);
      D.31630 = domain->runtime_info;
      D.31635 = MEM[(struct MonoJitDomainInfo *)D.31630].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.31635);
      goto <D.26729>;
      <D.26728>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.150 = jlist;
        tmp = jlist.150->list;
        goto <D.26723>;
        <D.26722>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.31637 = ji->ji;
          D.31638 = D.31637->code_start;
          if (D.31638 <= ip) goto <D.31639>; else goto <D.31640>;
          <D.31639>:
          D.31637 = ji->ji;
          D.31638 = D.31637->code_start;
          D.31637 = ji->ji;
          D.31641 = D.31637->code_size;
          D.31642 = (sizetype) D.31641;
          D.31643 = D.31638 + D.31642;
          if (D.31643 > ip) goto <D.31644>; else goto <D.31645>;
          <D.31644>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.31645>:
          <D.31640>:
        }
        tmp = tmp->next;
        <D.26723>:
        if (tmp != 0B) goto <D.26722>; else goto <D.26724>;
        <D.26724>:
        tmp = remove;
        goto <D.26726>;
        <D.26725>:
        jlist.150 = jlist;
        jlist.150 = jlist;
        D.31646 = jlist.150->list;
        D.31647 = tmp->data;
        D.31648 = monoeg_g_slist_delete_link (D.31646, D.31647);
        jlist.150->list = D.31648;
        tmp = tmp->next;
        <D.26726>:
        if (tmp != 0B) goto <D.26725>; else goto <D.26727>;
        <D.26727>:
        monoeg_g_slist_free (remove);
      }
      <D.26729>:
      D.31649 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.31649 != 0) goto <D.26728>; else goto <D.26730>;
      <D.26730>:
      {
        int ret;

        D.31606 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31606);
        if (ret != 0) goto <D.31650>; else goto <D.31651>;
        <D.31650>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31651>:
        D.31652 = ret != 0;
        D.31653 = (long int) D.31652;
        D.31654 = __builtin_expect (D.31653, 0);
        if (D.31654 != 0) goto <D.31655>; else goto <D.31656>;
        <D.31655>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.31656>:
      }
      D.31637 = ji->ji;
      mono_jit_info_table_remove (domain, D.31637);
      if (destroy != 0) goto <D.31657>; else goto <D.31658>;
      <D.31657>:
      D.31659 = ji->code_mp;
      mono_code_manager_destroy (D.31659);
      <D.31658>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.31665;
  struct MonoLMF * D.31668;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.31663>; else goto <D.31664>;
  <D.31663>:
  D.31665 = mono_thread_internal_current ();
  if (D.31665 == thread) goto <D.31666>; else goto <D.31667>;
  <D.31666>:
  mono_set_jit_tls (0B);
  <D.31667>:
  D.31668 = mono_get_lmf ();
  if (D.31668 != 0B) goto <D.31669>; else goto <D.31670>;
  <D.31669>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.31670>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.31664>:
}


free_jit_tls_data (struct MonoJitTlsData * jit_tls)
{
  struct MonoLMF * D.31671;

  mono_arch_free_jit_tls_data (jit_tls);
  mono_free_altstack (jit_tls);
  D.31671 = jit_tls->first_lmf;
  monoeg_g_free (D.31671);
  monoeg_g_free (jit_tls);
}


mini_get_imt_trampoline (int slot_index)
{
  void * D.31672;
  int D.31673;

  D.31673 = slot_index + -19;
  D.31672 = mini_get_vtable_trampoline (D.31673);
  return D.31672;
}


mini_get_addr_from_ftnptr (void * descr)
{
  void * D.31675;

  D.31675 = descr;
  return D.31675;
}


mini_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.31677;

  D.31677 = addr;
  return D.31677;
}


mini_parse_debug_options ()
{
  int D.31681;
  int D.31685;
  int D.31689;
  int D.31693;
  int D.31697;
  int D.31701;
  int D.31705;
  int D.31709;
  int D.31713;
  int D.31717;
  int D.31721;
  int D.31725;
  int D.31729;
  int D.31733;
  int D.31737;
  int D.31741;
  struct _IO_FILE * stderr.151;
  gchar * D.31747;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.31679>; else goto <D.31680>;
  <D.31679>:
  return;
  <D.31680>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.26845>;
  <D.26844>:
  {
    const char * arg;

    arg = *ptr;
    D.31681 = strcmp (arg, "handle-sigint");
    if (D.31681 == 0) goto <D.31682>; else goto <D.31683>;
    <D.31682>:
    debug_options.handle_sigint = 1;
    goto <D.31684>;
    <D.31683>:
    D.31685 = strcmp (arg, "keep-delegates");
    if (D.31685 == 0) goto <D.31686>; else goto <D.31687>;
    <D.31686>:
    debug_options.keep_delegates = 1;
    goto <D.31688>;
    <D.31687>:
    D.31689 = strcmp (arg, "reverse-pinvoke-exceptions");
    if (D.31689 == 0) goto <D.31690>; else goto <D.31691>;
    <D.31690>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.31692>;
    <D.31691>:
    D.31693 = strcmp (arg, "collect-pagefault-stats");
    if (D.31693 == 0) goto <D.31694>; else goto <D.31695>;
    <D.31694>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.31696>;
    <D.31695>:
    D.31697 = strcmp (arg, "break-on-unverified");
    if (D.31697 == 0) goto <D.31698>; else goto <D.31699>;
    <D.31698>:
    debug_options.break_on_unverified = 1;
    goto <D.31700>;
    <D.31699>:
    D.31701 = strcmp (arg, "no-gdb-backtrace");
    if (D.31701 == 0) goto <D.31702>; else goto <D.31703>;
    <D.31702>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.31704>;
    <D.31703>:
    D.31705 = strcmp (arg, "suspend-on-sigsegv");
    if (D.31705 == 0) goto <D.31706>; else goto <D.31707>;
    <D.31706>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.31708>;
    <D.31707>:
    D.31709 = strcmp (arg, "suspend-on-unhandled");
    if (D.31709 == 0) goto <D.31710>; else goto <D.31711>;
    <D.31710>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.31712>;
    <D.31711>:
    D.31713 = strcmp (arg, "dont-free-domains");
    if (D.31713 == 0) goto <D.31714>; else goto <D.31715>;
    <D.31714>:
    mono_dont_free_domains = 1;
    goto <D.31716>;
    <D.31715>:
    D.31717 = strcmp (arg, "dyn-runtime-invoke");
    if (D.31717 == 0) goto <D.31718>; else goto <D.31719>;
    <D.31718>:
    debug_options.dyn_runtime_invoke = 1;
    goto <D.31720>;
    <D.31719>:
    D.31721 = strcmp (arg, "gdb");
    if (D.31721 == 0) goto <D.31722>; else goto <D.31723>;
    <D.31722>:
    debug_options.gdb = 1;
    goto <D.31724>;
    <D.31723>:
    D.31725 = strcmp (arg, "explicit-null-checks");
    if (D.31725 == 0) goto <D.31726>; else goto <D.31727>;
    <D.31726>:
    debug_options.explicit_null_checks = 1;
    goto <D.31728>;
    <D.31727>:
    D.31729 = strcmp (arg, "gen-seq-points");
    if (D.31729 == 0) goto <D.31730>; else goto <D.31731>;
    <D.31730>:
    debug_options.gen_seq_points = 1;
    goto <D.31732>;
    <D.31731>:
    D.31733 = strcmp (arg, "init-stacks");
    if (D.31733 == 0) goto <D.31734>; else goto <D.31735>;
    <D.31734>:
    debug_options.init_stacks = 1;
    goto <D.31736>;
    <D.31735>:
    D.31737 = strcmp (arg, "casts");
    if (D.31737 == 0) goto <D.31738>; else goto <D.31739>;
    <D.31738>:
    debug_options.better_cast_details = 1;
    goto <D.31740>;
    <D.31739>:
    D.31741 = strcmp (arg, "soft-breakpoints");
    if (D.31741 == 0) goto <D.31742>; else goto <D.31743>;
    <D.31742>:
    debug_options.soft_breakpoints = 1;
    goto <D.31744>;
    <D.31743>:
    stderr.151 = stderr;
    fprintf (stderr.151, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.151 = stderr;
    fprintf (stderr.151, "Available options: \'handle-sigint\', \'keep-delegates\', \'reverse-pinvoke-exceptions\', \'collect-pagefault-stats\', \'break-on-unverified\', \'no-gdb-backtrace\', \'dont-free-domains\', \'suspend-on-sigsegv\', \'suspend-on-unhandled\', \'dyn-runtime-invoke\', \'gdb\', \'explicit-null-checks\', \'init-stacks\'\n");
    exit (1);
    <D.31744>:
    <D.31740>:
    <D.31736>:
    <D.31732>:
    <D.31728>:
    <D.31724>:
    <D.31720>:
    <D.31716>:
    <D.31712>:
    <D.31708>:
    <D.31704>:
    <D.31700>:
    <D.31696>:
    <D.31692>:
    <D.31688>:
    <D.31684>:
  }
  ptr = ptr + 8;
  <D.26845>:
  if (ptr != 0B) goto <D.31746>; else goto <D.26846>;
  <D.31746>:
  D.31747 = *ptr;
  if (D.31747 != 0B) goto <D.26844>; else goto <D.26846>;
  <D.26846>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.31749;
  void (*<Tc6>) (void *) destructor.152;
  int D.31751;
  _Bool D.31752;

  destructor.152 = (void (*<Tc6>) (void *)) destructor;
  D.31751 = pthread_key_create (key, destructor.152);
  D.31752 = D.31751 == 0;
  D.31749 = (int) D.31752;
  return D.31749;
}


register_jit_stats ()
{
  mono_counters_register ("Compiled methods", 258, &mono_jit_stats.methods_compiled);
  mono_counters_register ("Methods from AOT", 258, &mono_jit_stats.methods_aot);
  mono_counters_register ("Methods JITted using mono JIT", 256, &mono_jit_stats.methods_without_llvm);
  mono_counters_register ("Methods JITted using LLVM", 256, &mono_jit_stats.methods_with_llvm);
  mono_counters_register ("Total time spent JITting (sec)", 261, &mono_jit_stats.jit_time);
  mono_counters_register ("Basic blocks", 256, &mono_jit_stats.basic_blocks);
  mono_counters_register ("Max basic blocks", 256, &mono_jit_stats.max_basic_blocks);
  mono_counters_register ("Allocated vars", 256, &mono_jit_stats.allocate_var);
  mono_counters_register ("Code reallocs", 256, &mono_jit_stats.code_reallocs);
  mono_counters_register ("Allocated code size", 256, &mono_jit_stats.allocated_code_size);
  mono_counters_register ("Inlineable methods", 256, &mono_jit_stats.inlineable_methods);
  mono_counters_register ("Inlined methods", 256, &mono_jit_stats.inlined_methods);
  mono_counters_register ("Regvars", 256, &mono_jit_stats.regvars);
  mono_counters_register ("Locals stack size", 256, &mono_jit_stats.locals_stack_size);
  mono_counters_register ("Method cache lookups", 256, &mono_jit_stats.methods_lookups);
  mono_counters_register ("Compiled CIL code size", 256, &mono_jit_stats.cil_code_size);
  mono_counters_register ("Native code size", 256, &mono_jit_stats.native_code_size);
  mono_counters_register ("Aliases found", 256, &mono_jit_stats.alias_found);
  mono_counters_register ("Aliases eliminated", 256, &mono_jit_stats.alias_removed);
  mono_counters_register ("Aliased loads eliminated", 256, &mono_jit_stats.loads_eliminated);
  mono_counters_register ("Aliased stores eliminated", 256, &mono_jit_stats.stores_eliminated);
}


register_dyn_icall (void * func, const char * name, const char * sigstr, gboolean save)
{
  struct MonoMethodSignature * sig;

  if (sigstr != 0B) goto <D.31754>; else goto <D.31755>;
  <D.31754>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.31756>;
  <D.31755>:
  sig = 0B;
  <D.31756>:
  mono_register_jit_icall (func, name, sig, save);
}


register_opcode_emulation (int opcode, const char * name, const char * sigstr, void * func, const char * symbol, gboolean no_throw)
{
  long unsigned int D.31757;
  long unsigned int D.31758;
  _Bool D.31759;
  long int D.31760;
  long int D.31761;
  short unsigned int D.31764;
  _Bool D.31765;
  long int D.31766;
  long int D.31767;
  short int emul_opcode_num.153;
  short int emul_opcode_alloced.154;
  int iftmp.155;
  short int D.31777;
  unsigned short D.31779;
  unsigned short emul_opcode_alloced.156;
  unsigned short D.31781;
  short int D.31782;
  struct MonoJitICallInfo * * emul_opcode_map.157;
  long unsigned int D.31784;
  long unsigned int D.31785;
  void * D.31786;
  short int * emul_opcode_opcodes.158;
  long unsigned int D.31788;
  void * D.31789;
  long unsigned int D.31790;
  long unsigned int D.31791;
  struct MonoJitICallInfo * * D.31792;
  long unsigned int D.31793;
  short int * D.31794;
  short int D.31795;
  short int emul_opcode_num.159;
  unsigned short emul_opcode_num.160;
  unsigned short D.31798;
  short int D.31799;
  int D.31800;
  unsigned char D.31801;
  signed char D.31802;
  int D.31803;
  int D.31804;
  signed char D.31805;
  signed char D.31806;
  unsigned char D.31807;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.31757 = BIT_FIELD_REF <*sig, 64, 64>;
  D.31758 = D.31757 & 512;
  D.31759 = D.31758 != 0;
  D.31760 = (long int) D.31759;
  D.31761 = __builtin_expect (D.31760, 0);
  if (D.31761 != 0) goto <D.31762>; else goto <D.31763>;
  <D.31762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.31763>:
  D.31764 = sig->param_count;
  D.31765 = D.31764 > 2;
  D.31766 = (long int) D.31765;
  D.31767 = __builtin_expect (D.31766, 0);
  if (D.31767 != 0) goto <D.31768>; else goto <D.31769>;
  <D.31768>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.31769>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.153 = emul_opcode_num;
  emul_opcode_alloced.154 = emul_opcode_alloced;
  if (emul_opcode_num.153 >= emul_opcode_alloced.154) goto <D.31772>; else goto <D.31773>;
  <D.31772>:
  {
    int incr;

    emul_opcode_alloced.154 = emul_opcode_alloced;
    if (emul_opcode_alloced.154 != 0) goto <D.31775>; else goto <D.31776>;
    <D.31775>:
    emul_opcode_alloced.154 = emul_opcode_alloced;
    D.31777 = emul_opcode_alloced.154 / 2;
    iftmp.155 = (int) D.31777;
    goto <D.31778>;
    <D.31776>:
    iftmp.155 = 16;
    <D.31778>:
    incr = iftmp.155;
    D.31779 = (unsigned short) incr;
    emul_opcode_alloced.154 = emul_opcode_alloced;
    emul_opcode_alloced.156 = (unsigned short) emul_opcode_alloced.154;
    D.31781 = D.31779 + emul_opcode_alloced.156;
    D.31782 = (short int) D.31781;
    emul_opcode_alloced = D.31782;
    emul_opcode_map.157 = emul_opcode_map;
    emul_opcode_alloced.154 = emul_opcode_alloced;
    D.31784 = (long unsigned int) emul_opcode_alloced.154;
    D.31785 = D.31784 * 8;
    D.31786 = monoeg_realloc (emul_opcode_map.157, D.31785);
    emul_opcode_map = D.31786;
    emul_opcode_opcodes.158 = emul_opcode_opcodes;
    emul_opcode_alloced.154 = emul_opcode_alloced;
    D.31784 = (long unsigned int) emul_opcode_alloced.154;
    D.31788 = D.31784 * 2;
    D.31789 = monoeg_realloc (emul_opcode_opcodes.158, D.31788);
    emul_opcode_opcodes = D.31789;
  }
  <D.31773>:
  emul_opcode_map.157 = emul_opcode_map;
  emul_opcode_num.153 = emul_opcode_num;
  D.31790 = (long unsigned int) emul_opcode_num.153;
  D.31791 = D.31790 * 8;
  D.31792 = emul_opcode_map.157 + D.31791;
  *D.31792 = info;
  emul_opcode_opcodes.158 = emul_opcode_opcodes;
  emul_opcode_num.153 = emul_opcode_num;
  D.31790 = (long unsigned int) emul_opcode_num.153;
  D.31793 = D.31790 * 2;
  D.31794 = emul_opcode_opcodes.158 + D.31793;
  D.31795 = (short int) opcode;
  *D.31794 = D.31795;
  emul_opcode_num.153 = emul_opcode_num;
  emul_opcode_num.159 = emul_opcode_num.153;
  emul_opcode_num.160 = (unsigned short) emul_opcode_num.159;
  D.31798 = emul_opcode_num.160 + 1;
  D.31799 = (short int) D.31798;
  emul_opcode_num = D.31799;
  D.31800 = opcode >> 6;
  D.31800 = opcode >> 6;
  D.31801 = emul_opcode_hit_cache[D.31800];
  D.31802 = (signed char) D.31801;
  D.31803 = opcode & 7;
  D.31804 = 1 << D.31803;
  D.31805 = (signed char) D.31804;
  D.31806 = D.31802 | D.31805;
  D.31807 = (unsigned char) D.31806;
  emul_opcode_hit_cache[D.31800] = D.31807;
}


register_icall (void * func, const char * name, const char * sigstr, gboolean save)
{
  const char * iftmp.161;
  struct MonoMethodSignature * sig;

  if (sigstr != 0B) goto <D.31808>; else goto <D.31809>;
  <D.31808>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.31810>;
  <D.31809>:
  sig = 0B;
  <D.31810>:
  if (save != 0) goto <D.31812>; else goto <D.31813>;
  <D.31812>:
  iftmp.161 = name;
  goto <D.31814>;
  <D.31813>:
  iftmp.161 = 0B;
  <D.31814>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.161);
}


__attribute__((visibility ("hidden")))
mini_cleanup (struct MonoDomain * domain)
{
  unsigned int mono_jit_tls_id.162;
  void * D.31816;
  int mono_dont_free_global_codeman.163;
  struct MonoCodeManager * global_codeman.164;
  struct GHashTable * jit_icall_name_hash.165;
  struct MonoJitICallInfo * * emul_opcode_map.166;
  short int * emul_opcode_opcodes.167;
  void * * vtable_trampolines.168;
  struct _IO_FILE * stdout.169;
  struct MonoMethodDesc * mono_inject_async_exc_method.170;

  mono_runtime_shutdown_stat_profiler ();
  cominterop_release_all_rcws ();
  mono_domain_finalize (domain, 2000);
  print_jit_stats ();
  mono_profiler_shutdown ();
  mono_runtime_cleanup (domain);
  mono_jit_tls_id.162 = mono_jit_tls_id;
  D.31816 = pthread_getspecific (mono_jit_tls_id.162);
  free_jit_tls_data (D.31816);
  mono_icall_cleanup ();
  mono_runtime_cleanup_handlers ();
  mono_domain_free (domain, 1);
  mono_aot_cleanup ();
  mono_trampolines_cleanup ();
  mono_unwind_cleanup ();
  mono_dont_free_global_codeman.163 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.163 == 0) goto <D.31818>; else goto <D.31819>;
  <D.31818>:
  global_codeman.164 = global_codeman;
  mono_code_manager_destroy (global_codeman.164);
  <D.31819>:
  jit_icall_name_hash.165 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.165);
  emul_opcode_map.166 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.166);
  emul_opcode_opcodes.167 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.167);
  vtable_trampolines.168 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.168);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.169 = stdout;
  mono_counters_dump (-1, stdout.169);
  mono_inject_async_exc_method.170 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.170 != 0B) goto <D.31827>; else goto <D.31828>;
  <D.31827>:
  mono_inject_async_exc_method.170 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.170);
  <D.31828>:
  mono_jit_tls_id.162 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.162);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.31829;
  int D.31832;
  double D.31833;
  double D.31834;
  char * D.31835;
  int D.31836;
  char * D.31837;
  long unsigned int D.31838;
  long unsigned int D.31839;
  long unsigned int D.31840;
  long unsigned int D.31841;
  long unsigned int D.31842;
  long unsigned int D.31843;
  long unsigned int D.31844;
  struct MonoImage * D.31845;
  struct MonoMemPool * D.31846;
  unsigned int D.31847;
  long unsigned int D.31848;
  long unsigned int D.31849;
  int D.31850;
  long unsigned int D.31851;
  long unsigned int D.31852;
  long unsigned int D.31853;
  long unsigned int D.31854;
  long unsigned int D.31855;
  long unsigned int D.31856;
  long unsigned int D.31857;
  long unsigned int D.31858;
  long unsigned int D.31859;
  long unsigned int D.31860;
  long unsigned int D.31861;
  long unsigned int D.31862;
  long unsigned int D.31863;
  long unsigned int D.31864;
  long unsigned int D.31865;
  long unsigned int D.31866;
  long unsigned int D.31867;
  long unsigned int D.31868;
  long unsigned int D.31869;
  <unnamed type> D.31870;
  int D.31873;
  int D.31874;
  int D.31875;
  int D.31876;
  int D.31877;
  int D.31878;

  D.31829 = mono_jit_stats.enabled;
  if (D.31829 != 0) goto <D.31830>; else goto <D.31831>;
  <D.31830>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.31832 = mono_jit_stats.max_code_size_ratio;
  D.31833 = (double) D.31832;
  D.31834 = D.31833 / 1.0e+2;
  D.31835 = mono_jit_stats.max_ratio_method;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.31834, D.31835);
  D.31836 = mono_jit_stats.biggest_method_size;
  D.31837 = mono_jit_stats.biggest_method;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.31836, D.31837);
  D.31838 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.31838);
  D.31839 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.31839);
  D.31840 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.31840);
  D.31841 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.31841);
  D.31842 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.31842);
  D.31843 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.31843);
  D.31844 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.31844);
  D.31845 = mono_defaults.corlib;
  D.31846 = D.31845->mempool;
  D.31847 = mono_mempool_get_allocated (D.31846);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.31847);
  D.31848 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.31848);
  D.31849 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.31849);
  D.31850 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.31850);
  D.31851 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.31851);
  D.31852 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.31852);
  D.31853 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.31853);
  D.31854 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.31854);
  D.31855 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.31855);
  D.31856 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.31856);
  D.31857 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.31857);
  D.31858 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.31858);
  D.31859 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.31859);
  D.31860 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.31860);
  D.31861 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.31861);
  D.31862 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.31862);
  D.31863 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.31863);
  D.31864 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.31864);
  D.31865 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.31865);
  D.31866 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.31866);
  D.31867 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.31867);
  D.31868 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.31868);
  D.31869 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.31869);
  D.31870 = mono_security_get_mode ();
  if (D.31870 == 2) goto <D.31871>; else goto <D.31872>;
  <D.31871>:
  D.31873 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.31873);
  D.31874 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.31874);
  D.31875 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.31875);
  D.31876 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.31876);
  D.31877 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.31877);
  D.31878 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.31878);
  <D.31872>:
  D.31835 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.31835);
  mono_jit_stats.max_ratio_method = 0B;
  D.31837 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.31837);
  mono_jit_stats.biggest_method = 0B;
  <D.31831>:
}


mono_native_tls_free (pthread_key_t key)
{
  pthread_key_delete (key);
}


mono_set_defaults (int verbose_level, guint32 opts)
{
  mini_verbose = verbose_level;
  mono_set_optimizations (opts);
}


__attribute__((visibility ("hidden")))
mono_disable_optimizations (guint32 opts)
{
  unsigned int D.31879;
  unsigned int default_opt.171;
  unsigned int D.31881;

  D.31879 = ~opts;
  default_opt.171 = default_opt;
  D.31881 = D.31879 & default_opt.171;
  default_opt = D.31881;
}


__attribute__((visibility ("hidden")))
mono_set_optimizations (guint32 opts)
{
  default_opt = opts;
  default_opt_set = 1;
}


__attribute__((visibility ("hidden")))
mono_set_verbose_level (guint32 level)
{
  int level.172;

  level.172 = (int) level;
  mini_verbose = level.172;
}


mono_get_runtime_build_info ()
{
  const char * mono_build_date.173;
  char * D.31886;

  mono_build_date.173 = mono_build_date;
  if (mono_build_date.173 != 0B) goto <D.31884>; else goto <D.31885>;
  <D.31884>:
  mono_build_date.173 = mono_build_date;
  D.31886 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.173);
  return D.31886;
  <D.31885>:
  D.31886 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.31886;
}


__attribute__((visibility ("hidden")))
mono_precompile_assemblies ()
{
  struct GHashTable * assemblies;

  assemblies = monoeg_g_hash_table_new (0B, 0B);
  mono_assembly_foreach (mono_precompile_assembly, assemblies);
  monoeg_g_hash_table_destroy (assemblies);
}


mono_precompile_assembly (struct MonoAssembly * ass, void * user_data)
{
  void * D.31888;
  int mini_verbose.174;
  const char * D.31894;
  int D.31895;
  int D.31896;
  unsigned int D.31897;
  short unsigned int D.31898;
  int D.31899;
  int D.31900;
  const char * D.31905;
  int D.31906;
  struct MonoClass * D.31909;
  long unsigned int D.31910;
  long unsigned int D.31911;
  struct MonoMethodSignature * D.31914;
  long unsigned int D.31915;
  long unsigned int D.31916;
  int D.31919;
  struct MonoAssembly * * D.31920;
  long unsigned int D.31921;
  long unsigned int D.31922;
  struct MonoAssembly * * D.31923;
  struct MonoAssembly * D.31924;
  int D.31927;
  struct GHashTable * assemblies;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct MonoMethod * invoke;
  int i;
  int count;

  assemblies = user_data;
  image = mono_assembly_get_image (ass);
  count = 0;
  D.31888 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.31888 != 0B) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  return;
  <D.31890>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.174 = mini_verbose;
  if (mini_verbose.174 > 0) goto <D.31892>; else goto <D.31893>;
  <D.31892>:
  D.31894 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.31894);
  <D.31893>:
  i = 0;
  goto <D.26948>;
  <D.26947>:
  D.31895 = i + 1;
  D.31896 = D.31895 | 100663296;
  D.31897 = (unsigned int) D.31896;
  method = mono_get_method (image, D.31897, 0B);
  D.31898 = method->flags;
  D.31899 = (int) D.31898;
  D.31900 = D.31899 & 1024;
  if (D.31900 != 0) goto <D.31901>; else goto <D.31902>;
  <D.31901>:
  // predicted unlikely by continue predictor.
  goto <D.26945>;
  <D.31902>:
  count = count + 1;
  mini_verbose.174 = mini_verbose;
  if (mini_verbose.174 > 1) goto <D.31903>; else goto <D.31904>;
  <D.31903>:
  {
    char * desc;

    desc = mono_method_full_name (method, 1);
    monoeg_g_print ("Compiling %d %s\n", count, desc);
    monoeg_g_free (desc);
  }
  <D.31904>:
  mono_compile_method (method);
  D.31905 = method->name;
  D.31906 = strcmp (D.31905, "Finalize");
  if (D.31906 == 0) goto <D.31907>; else goto <D.31908>;
  <D.31907>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.31908>:
  D.31909 = method->klass;
  D.31910 = BIT_FIELD_REF <*D.31909, 64, 256>;
  D.31911 = D.31910 & 2199023255552;
  if (D.31911 != 0) goto <D.31912>; else goto <D.31913>;
  <D.31912>:
  D.31914 = mono_method_signature (method);
  D.31915 = BIT_FIELD_REF <*D.31914, 64, 64>;
  D.31916 = D.31915 & 512;
  if (D.31916 != 0) goto <D.31917>; else goto <D.31918>;
  <D.31917>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.31918>:
  <D.31913>:
  <D.26945>:
  i = i + 1;
  <D.26948>:
  D.31919 = mono_image_get_table_rows (image, 6);
  if (D.31919 > i) goto <D.26947>; else goto <D.26949>;
  <D.26949>:
  i = 0;
  goto <D.26951>;
  <D.26950>:
  mono_assembly_load_reference (image, i);
  D.31920 = image->references;
  D.31921 = (long unsigned int) i;
  D.31922 = D.31921 * 8;
  D.31923 = D.31920 + D.31922;
  D.31924 = *D.31923;
  if (D.31924 != 0B) goto <D.31925>; else goto <D.31926>;
  <D.31925>:
  D.31920 = image->references;
  D.31921 = (long unsigned int) i;
  D.31922 = D.31921 * 8;
  D.31923 = D.31920 + D.31922;
  D.31924 = *D.31923;
  mono_precompile_assembly (D.31924, assemblies);
  <D.31926>:
  i = i + 1;
  <D.26951>:
  D.31927 = mono_image_get_table_rows (image, 35);
  if (D.31927 > i) goto <D.26950>; else goto <D.26952>;
  <D.26952>:
}


__attribute__((visibility ("hidden")))
mono_arch_instrument_epilog (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments)
{
  void * D.31929;

  D.31929 = mono_arch_instrument_epilog_full (cfg, func, p, enable_arguments, 0);
  return D.31929;
}


__attribute__((visibility ("hidden")))
mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.31931;
  long int start.175;
  unsigned char * D.31933;
  long int D.31934;
  long int D.31935;
  int D.31936;
  struct GSList * D.31937;
  struct GSList * D.31938;
  struct TryBlockHole * hole;

  D.31931 = cfg->mempool;
  hole = mono_mempool_alloc (D.31931, 24);
  hole->clause = clause;
  start.175 = (long int) start;
  D.31933 = cfg->native_code;
  D.31934 = (long int) D.31933;
  D.31935 = start.175 - D.31934;
  D.31936 = (int) D.31935;
  hole->start_offset = D.31936;
  hole->basic_block = bb;
  D.31931 = cfg->mempool;
  D.31937 = cfg->try_block_holes;
  D.31938 = g_slist_append_mempool (D.31931, D.31937, hole);
  cfg->try_block_holes = D.31938;
}


__attribute__((visibility ("hidden")))
mono_cfg_set_exception (struct MonoCompile * cfg, int type)
{
  unsigned int type.176;

  type.176 = (unsigned int) type;
  cfg->exception_type = type.176;
}


__attribute__((visibility ("hidden")))
mono_arch_gsharedvt_sig_supported (struct MonoMethodSignature * sig)
{
  gboolean D.31940;

  D.31940 = 0;
  return D.31940;
}


__attribute__((visibility ("hidden")))
mono_arch_get_gsharedvt_call_info (void * addr, struct MonoMethodSignature * normal_sig, struct MonoMethodSignature * gsharedvt_sig, struct MonoGenericSharingContext * gsctx, gboolean gsharedvt_in, gint32 vcall_offset, gboolean calli)
{
  void * D.31942;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 7831);
  D.31942 = 0B;
  return D.31942;
}


__attribute__((visibility ("hidden")))
mono_arch_get_gsharedvt_arg_trampoline (struct MonoDomain * domain, void * arg, void * addr)
{
  void * D.31944;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 7838);
  D.31944 = 0B;
  return D.31944;
}


__attribute__((visibility ("hidden")))
mono_arch_get_gsharedvt_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.31946;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 7845);
  D.31946 = 0B;
  return D.31946;
}


__attribute__((visibility ("hidden")))
mini_replace_type (struct MonoType * type)
{
  struct MonoType * D.31948;

  D.31948 = mono_type_get_underlying_type (type);
  return D.31948;
}