mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.27072;
  unsigned int D.27073;
  long unsigned int D.27074;
  unsigned char * D.27075;

  D.27073 = cfg->code_size;
  D.27074 = (long unsigned int) D.27073;
  D.27075 = cfg->native_code;
  D.27072 = monoeg_realloc (D.27075, D.27074);
  return D.27072;
}


mono_running_on_valgrind ()
{
  volatile long long unsigned int D.24919;
  unsigned int D.27077;
  gboolean D.27080;

  {
    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__("rolq $3,  %%rdi ; rolq $13, %%rdi
	rolq $61, %%rdi ; rolq $51, %%rdi
	xchgq %%rbx,%%rbx" : "=d" _zzq_result : "a" &_zzq_args[0], "0" 0 : "memory", "cc");
    D.24919 = _zzq_result;
  }
  D.27077 = (unsigned int) D.24919;
  if (D.27077 != 0) goto <D.27078>; else goto <D.27079>;
  <D.27078>:
  D.27080 = 1;
  return D.27080;
  <D.27079>:
  D.27080 = 0;
  return D.27080;
}


mono_pmip (void * ip)
{
  char * D.27082;

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


get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.27088;
  _Bool D.27091;
  long int D.27092;
  long int D.27093;
  void * D.27096;
  struct GHashTable * D.27097;
  _Bool D.27100;
  long int D.27101;
  long int D.27102;
  struct MonoMethod * D.27105;
  char * D.27108;
  struct MonoMethod * D.27109;
  long int ip.0;
  void * D.27111;
  long int D.27112;
  long int D.27113;
  unsigned int D.27114;
  struct MonoMethod * D.27115;
  char * D.27116;
  int D.27117;
  sizetype D.27118;
  char * D.27119;
  int D.27120;
  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.27084>; else goto <D.27085>;
      <D.27084>:
      domain = mono_get_root_domain ();
      <D.27085>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.27086>; else goto <D.27087>;
      <D.27086>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.27088 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27088);
        if (ret != 0) goto <D.27089>; else goto <D.27090>;
        <D.27089>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27090>:
        D.27091 = ret != 0;
        D.27092 = (long int) D.27091;
        D.27093 = __builtin_expect (D.27092, 0);
        if (D.27093 != 0) goto <D.27094>; else goto <D.27095>;
        <D.27094>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 305, "ret == 0");
        <D.27095>:
      }
      D.27096 = domain->runtime_info;
      D.27097 = MEM[(struct MonoJitDomainInfo *)D.27096].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.27097, find_tramp, &user_data);
      {
        int ret;

        D.27088 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27088);
        if (ret != 0) goto <D.27098>; else goto <D.27099>;
        <D.27098>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27099>:
        D.27100 = ret != 0;
        D.27101 = (long int) D.27100;
        D.27102 = __builtin_expect (D.27101, 0);
        if (D.27102 != 0) goto <D.27103>; else goto <D.27104>;
        <D.27103>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 307, "ret == 0");
        <D.27104>:
      }
      D.27105 = user_data.method;
      if (D.27105 != 0B) goto <D.27106>; else goto <D.27107>;
      <D.27106>:
      {
        char * mname;

        D.27105 = user_data.method;
        mname = mono_method_full_name (D.27105, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.27108 = res;
        return D.27108;
      }
      <D.27107>:
      D.27108 = 0B;
      return D.27108;
      <D.27087>:
      D.27109 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27109, 1);
      ip.0 = (long int) ip;
      D.27111 = ji->code_start;
      D.27112 = (long int) D.27111;
      D.27113 = ip.0 - D.27112;
      D.27114 = (unsigned int) D.27113;
      D.27115 = jinfo_get_method (ji);
      location = mono_debug_lookup_source_location (D.27115, D.27114, domain);
      D.27116 = domain->friendly_name;
      D.27111 = ji->code_start;
      D.27117 = ji->code_size;
      D.27118 = (sizetype) D.27117;
      D.27119 = D.27111 + D.27118;
      D.27111 = ji->code_start;
      ip.0 = (long int) ip;
      D.27111 = ji->code_start;
      D.27112 = (long int) D.27111;
      D.27113 = ip.0 - D.27112;
      D.27120 = (int) D.27113;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.27120, D.27111, D.27119, domain, D.27116);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.27108 = res;
      return D.27108;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


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

  ud = user_data;
  D.27123 = ud->ip;
  if (D.27123 == value) goto <D.27124>; else goto <D.27125>;
  <D.27124>:
  ud->method = key;
  <D.27125>:
}


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

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


mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.27131;
  _Bool D.27134;
  long int D.27135;
  long int D.27136;
  void * D.27139;
  struct GHashTable * D.27140;
  _Bool D.27143;
  long int D.27144;
  long int D.27145;
  struct MonoMethod * D.27148;
  guint8 * D.27151;
  unsigned int D.27154;
  sizetype D.27155;
  guint8 * D.27156;
  char * D.27159;
  long int ip.2;
  long int D.27161;
  long int D.27162;
  int D.27163;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.27165;
  struct MonoDomain * target_domain.4;
  void * D.27167;
  long int D.27168;
  long int D.27169;
  unsigned int D.27170;
  struct MonoMethod * D.27171;
  gboolean * D.27177;
  gboolean * D.27179;
  char * D.27180;
  int D.27181;
  sizetype D.27182;
  char * D.27183;
  int D.27184;
  unsigned int D.27187;
  char * D.27188;
  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.27129>; else goto <D.27130>;
      <D.27129>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.27131 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27131);
        if (ret != 0) goto <D.27132>; else goto <D.27133>;
        <D.27132>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27133>:
        D.27134 = ret != 0;
        D.27135 = (long int) D.27134;
        D.27136 = __builtin_expect (D.27135, 0);
        if (D.27136 != 0) goto <D.27137>; else goto <D.27138>;
        <D.27137>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.27138>:
      }
      D.27139 = domain->runtime_info;
      D.27140 = MEM[(struct MonoJitDomainInfo *)D.27139].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.27140, find_tramp, &user_data);
      {
        int ret;

        D.27131 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27131);
        if (ret != 0) goto <D.27141>; else goto <D.27142>;
        <D.27141>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27142>:
        D.27143 = ret != 0;
        D.27144 = (long int) D.27143;
        D.27145 = __builtin_expect (D.27144, 0);
        if (D.27145 != 0) goto <D.27146>; else goto <D.27147>;
        <D.27146>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.27147>:
      }
      D.27148 = user_data.method;
      if (D.27148 != 0B) goto <D.27149>; else goto <D.27150>;
      <D.27149>:
      {
        char * mname;

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

        tinfo = l->data;
        D.27151 = tinfo->code;
        if (D.27151 <= ip) goto <D.27152>; else goto <D.27153>;
        <D.27152>:
        D.27151 = tinfo->code;
        D.27154 = tinfo->code_size;
        D.27155 = (sizetype) D.27154;
        D.27156 = D.27151 + D.27155;
        if (D.27156 >= ip) goto <D.27157>; else goto <D.27158>;
        <D.27157>:
        D.27159 = tinfo->name;
        ip.2 = (long int) ip;
        D.27151 = tinfo->code;
        D.27161 = (long int) D.27151;
        D.27162 = ip.2 - D.27161;
        D.27163 = (int) D.27162;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.27163, D.27159);
        return;
        <D.27158>:
        <D.27153>:
      }
      l = l->next;
      <D.24967>:
      if (l != 0B) goto <D.24966>; else goto <D.24968>;
      <D.24968>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.27130>:
      D.27165 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27165, 1);
      target_domain.4 = target_domain;
      ip.2 = (long int) ip;
      D.27167 = ji->code_start;
      D.27168 = (long int) D.27167;
      D.27169 = ip.2 - D.27168;
      D.27170 = (unsigned int) D.27169;
      D.27171 = jinfo_get_method (ji);
      source = mono_debug_lookup_source_location (D.27171, D.27170, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.27172>; else goto <D.27173>;
      <D.27172>:
      D.27177 = gsctx->var_is_vt;
      if (D.27177 != 0B) goto <D.27174>; else goto <D.27178>;
      <D.27178>:
      D.27179 = gsctx->mvar_is_vt;
      if (D.27179 != 0B) goto <D.27174>; else goto <D.27175>;
      <D.27174>:
      shared_type = "gsharedvt ";
      goto <D.27176>;
      <D.27175>:
      shared_type = "gshared ";
      <D.27176>:
      <D.27173>:
      target_domain.4 = target_domain;
      D.27180 = target_domain.4->friendly_name;
      target_domain.4 = target_domain;
      D.27167 = ji->code_start;
      D.27181 = ji->code_size;
      D.27182 = (sizetype) D.27181;
      D.27183 = D.27167 + D.27182;
      D.27167 = ji->code_start;
      ip.2 = (long int) ip;
      D.27167 = ji->code_start;
      D.27168 = (long int) D.27167;
      D.27169 = ip.2 - D.27168;
      D.27184 = (int) D.27169;
      monoeg_g_print ("IP %p at offset 0x%x of %smethod %s (%p %p)[domain %p - %s]\n", ip, D.27184, shared_type, method, D.27167, D.27183, target_domain.4, D.27180);
      if (source != 0B) goto <D.27185>; else goto <D.27186>;
      <D.27185>:
      D.27187 = source->row;
      D.27188 = source->source_file;
      monoeg_g_print ("%s:%d\n", D.27188, D.27187);
      <D.27186>:
      stdout.3 = stdout;
      fflush (stdout.3);
      mono_debug_free_source_location (source);
      monoeg_g_free (method);
    }
  finally
    {
      target_domain = {CLOBBER};
      user_data = {CLOBBER};
    }
}


printf (const char * restrict __fmt)
{
  int D.27192;

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


mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  _Bool D.27194;
  _Bool D.27195;
  _Bool D.27196;
  gboolean D.27199;
  unsigned char D.27200;
  unsigned char D.27201;
  unsigned char D.27204;
  unsigned char D.27205;
  struct MonoClass * D.27208;
  struct MonoClass * D.27209;
  const char * D.27212;
  char * D.27213;
  struct MonoMethod * cmethod;

  D.27194 = caller == 0B;
  D.27195 = callee == 0B;
  D.27196 = D.27194 | D.27195;
  if (D.27196 != 0) goto <D.27197>; else goto <D.27198>;
  <D.27197>:
  D.27199 = 0;
  return D.27199;
  <D.27198>:
  D.27200 = BIT_FIELD_REF <*caller, 8, 264>;
  D.27201 = D.27200 & 128;
  if (D.27201 != 0) goto <D.27202>; else goto <D.27203>;
  <D.27202>:
  D.27204 = BIT_FIELD_REF <*callee, 8, 264>;
  D.27205 = D.27204 & 128;
  if (D.27205 == 0) goto <D.27206>; else goto <D.27207>;
  <D.27206>:
  D.27199 = 0;
  return D.27199;
  <D.27207>:
  <D.27203>:
  cmethod = jinfo_get_method (caller);
  D.27208 = cmethod->klass;
  D.27209 = mono_defaults.appdomain_class;
  if (D.27208 == D.27209) goto <D.27210>; else goto <D.27211>;
  <D.27210>:
  D.27212 = cmethod->name;
  D.27213 = strstr (D.27212, "InvokeInDomain");
  if (D.27213 != 0B) goto <D.27214>; else goto <D.27215>;
  <D.27214>:
  D.27199 = 0;
  return D.27199;
  <D.27215>:
  <D.27211>:
  D.27199 = 1;
  return D.27199;
}


mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * global_codeman.7;
  void * D.27224;
  _Bool D.27227;
  long int D.27228;
  long int D.27229;
  _Bool D.27234;
  long int D.27235;
  long int D.27236;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.27218>; else goto <D.27219>;
  <D.27218>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.24978>:
  goto <D.24978>;
  <D.27219>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.27221>; else goto <D.27222>;
  <D.27221>:
  global_codeman.7 = mono_code_manager_new ();
  global_codeman = global_codeman.7;
  global_codeman.6 = global_codeman;
  D.27224 = mono_code_manager_reserve (global_codeman.6, size);
  return D.27224;
  <D.27222>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27225>; else goto <D.27226>;
    <D.27225>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27226>:
    D.27227 = ret != 0;
    D.27228 = (long int) D.27227;
    D.27229 = __builtin_expect (D.27228, 0);
    if (D.27229 != 0) goto <D.27230>; else goto <D.27231>;
    <D.27230>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.27231>:
  }
  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.27232>; else goto <D.27233>;
    <D.27232>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27233>:
    D.27234 = ret != 0;
    D.27235 = (long int) D.27234;
    D.27236 = __builtin_expect (D.27235, 0);
    if (D.27236 != 0) goto <D.27237>; else goto <D.27238>;
    <D.27237>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.27238>:
  }
  D.27224 = ptr;
  return D.27224;
}


nacl_global_codeman_get_dest (void * data)
{
  void * D.27240;

  D.27240 = data;
  return D.27240;
}


mono_global_codeman_commit (void * data, int size, int newsize)
{

}


nacl_global_codeman_validate (guint8 * * buf_base, int buf_size, guint8 * * code_end)
{

}


mono_create_unwind_op (int when, int tag, int reg, int val)
{
  unsigned char D.27242;
  short unsigned int D.27243;
  unsigned int when.8;
  struct MonoUnwindOp * D.27245;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.27242 = (unsigned char) tag;
  op->op = D.27242;
  D.27243 = (short unsigned int) reg;
  op->reg = D.27243;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.27245 = op;
  return D.27245;
}


mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.27247;
  unsigned char D.27248;
  short unsigned int D.27249;
  unsigned int when.9;
  struct GSList * D.27251;
  struct GSList * D.27252;
  unsigned int D.27253;
  const char * D.27256;
  const char * D.27257;
  int D.27258;
  const char * D.27259;
  struct MonoUnwindOp * op;

  D.27247 = cfg->mempool;
  op = mono_mempool_alloc0 (D.27247, 12);
  D.27248 = (unsigned char) tag;
  op->op = D.27248;
  D.27249 = (short unsigned int) reg;
  op->reg = D.27249;
  op->val = val;
  when.9 = (unsigned int) when;
  op->when = when.9;
  D.27251 = cfg->unwind_ops;
  D.27247 = cfg->mempool;
  D.27252 = g_slist_append_mempool (D.27247, D.27251, op);
  cfg->unwind_ops = D.27252;
  D.27253 = cfg->verbose_level;
  if (D.27253 > 1) goto <D.27254>; else goto <D.27255>;
  <D.27254>:
  switch (tag) <default: <D.27260>, case 12: <D.25009>, case 13: <D.25011>, case 14: <D.25012>, case 128: <D.25013>>
  <D.25009>:
  D.27256 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.27256, val);
  goto <D.25010>;
  <D.25011>:
  D.27257 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.27257);
  goto <D.25010>;
  <D.25012>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.25010>;
  <D.25013>:
  D.27258 = -val;
  D.27259 = mono_arch_regname (reg);
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.27259, D.27258);
  goto <D.25010>;
  <D.27260>:
  <D.25010>:
  <D.27255>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.27263;
  struct GSList * D.27264;
  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.27261>; else goto <D.27262>;
  <D.27261>:
  last = list;
  goto <D.14071>;
  <D.14070>:
  last = last->next;
  <D.14071>:
  D.27263 = last->next;
  if (D.27263 != 0B) goto <D.14070>; else goto <D.14072>;
  <D.14072>:
  last->next = new_list;
  D.27264 = list;
  return D.27264;
  <D.27262>:
  D.27264 = new_list;
  return D.27264;
}


mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.27266;
  int D.27267;
  struct MonoGenericContext * D.27270;
  struct MonoJumpInfoToken * D.27271;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 32);
  res->image = image;
  res->token = token;
  D.27266 = context != 0B;
  D.27267 = (int) D.27266;
  res->has_context = D.27267;
  if (context != 0B) goto <D.27268>; else goto <D.27269>;
  <D.27268>:
  D.27270 = &res->context;
  memcpy (D.27270, context, 16);
  <D.27269>:
  D.27271 = res;
  return D.27271;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.27273;
  long unsigned int D.27274;

  D.27274 = __builtin_object_size (__dest, 0);
  D.27273 = __builtin___memcpy_chk (__dest, __src, __len, D.27274);
  return D.27273;
}


mono_jump_info_token_new (struct MonoMemPool * mp, struct MonoImage * image, guint32 token)
{
  struct MonoJumpInfoToken * D.27276;

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


mono_tramp_info_create (const char * name, guint8 * code, guint32 code_size, struct MonoJumpInfo * ji, struct GSList * unwind_ops)
{
  gchar * D.27278;
  struct MonoTrampInfo * D.27279;
  struct MonoTrampInfo * info;

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


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

  if (str != 0B) goto <D.27281>; else goto <D.27282>;
  <D.27281>:
  D.27283 = __strdup (str);
  return D.27283;
  <D.27282>:
  D.27283 = 0B;
  return D.27283;
}


mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.27285;
  void * D.27286;
  struct GSList * D.27287;
  struct GSList * l;

  D.27285 = info->name;
  monoeg_g_free (D.27285);
  l = info->unwind_ops;
  goto <D.25039>;
  <D.25038>:
  D.27286 = l->data;
  monoeg_g_free (D.27286);
  l = l->next;
  <D.25039>:
  if (l != 0B) goto <D.25038>; else goto <D.25040>;
  <D.25040>:
  D.27287 = info->unwind_ops;
  monoeg_g_slist_free (D.27287);
  monoeg_g_free (info);
}


mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.27290;
  unsigned int D.27291;
  char * D.27292;
  gchar * D.27293;
  _Bool D.27296;
  long int D.27297;
  long int D.27298;
  struct GSList * tramp_infos.10;
  struct GSList * tramp_infos.11;
  _Bool D.27305;
  long int D.27306;
  long int D.27307;
  int D.27310;
  int D.27313;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.27288>; else goto <D.27289>;
  <D.27288>:
  return;
  <D.27289>:
  copy = monoeg_malloc0 (56);
  D.27290 = info->code;
  copy->code = D.27290;
  D.27291 = info->code_size;
  copy->code_size = D.27291;
  D.27292 = info->name;
  D.27293 = monoeg_strdup (D.27292);
  copy->name = D.27293;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27294>; else goto <D.27295>;
    <D.27294>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27295>:
    D.27296 = ret != 0;
    D.27297 = (long int) D.27296;
    D.27298 = __builtin_expect (D.27297, 0);
    if (D.27298 != 0) goto <D.27299>; else goto <D.27300>;
    <D.27299>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.27300>:
  }
  tramp_infos.10 = tramp_infos;
  tramp_infos.11 = monoeg_g_slist_prepend (tramp_infos.10, copy);
  tramp_infos = tramp_infos.11;
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27303>; else goto <D.27304>;
    <D.27303>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27304>:
    D.27305 = ret != 0;
    D.27306 = (long int) D.27305;
    D.27307 = __builtin_expect (D.27306, 0);
    if (D.27307 != 0) goto <D.27308>; else goto <D.27309>;
    <D.27308>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.27309>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.27310 = mono_jit_map_is_enabled ();
  if (D.27310 != 0) goto <D.27311>; else goto <D.27312>;
  <D.27311>:
  D.27292 = info->name;
  D.27291 = info->code_size;
  D.27313 = (int) D.27291;
  D.27290 = info->code;
  mono_emit_jit_tramp (D.27290, D.27313, D.27292);
  <D.27312>:
  mono_tramp_info_free (info);
}


mono_debug_count ()
{
  int count.12;
  int count.13;
  const gchar * D.27317;
  gboolean D.27320;
  const gchar * D.27321;
  int D.27322;
  const gchar * D.27325;
  int D.27326;
  static int count = 0;

  count.12 = count;
  count.13 = count.12 + 1;
  count = count.13;
  D.27317 = monoeg_g_getenv ("COUNT");
  if (D.27317 == 0B) goto <D.27318>; else goto <D.27319>;
  <D.27318>:
  D.27320 = 1;
  return D.27320;
  <D.27319>:
  D.27321 = monoeg_g_getenv ("COUNT");
  D.27322 = atoi (D.27321);
  count.12 = count;
  if (D.27322 == count.12) goto <D.27323>; else goto <D.27324>;
  <D.27323>:
  break_count ();
  <D.27324>:
  D.27325 = monoeg_g_getenv ("COUNT");
  D.27326 = atoi (D.27325);
  count.12 = count;
  if (D.27326 < count.12) goto <D.27327>; else goto <D.27328>;
  <D.27327>:
  D.27320 = 0;
  return D.27320;
  <D.27328>:
  D.27320 = 1;
  return D.27320;
}


break_count ()
{

}


atoi (const char * __nptr)
{
  int D.27330;
  long int D.27331;

  D.27331 = strtol (__nptr, 0B, 10);
  D.27330 = (int) D.27331;
  return D.27330;
}


mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.27333;
  long unsigned int D.27334;
  long unsigned int D.27335;
  struct MonoBasicBlock * * D.27336;
  struct MonoBasicBlock * D.27337;
  short int D.27340;
  int D.27341;
  int pos.14;
  long unsigned int D.27347;
  long unsigned int D.27348;
  struct MonoBasicBlock * * D.27349;
  int D.27350;
  _Bool D.27351;
  long int D.27352;
  long int D.27353;
  short int D.27356;
  unsigned short D.27357;
  unsigned short D.27358;
  short int D.27359;
  struct MonoBasicBlock * * D.27360;
  struct MonoBasicBlock * * D.27361;
  struct MonoBasicBlock * D.27362;
  short int D.27365;
  int D.27366;
  int pos.15;
  long unsigned int D.27372;
  long unsigned int D.27373;
  struct MonoBasicBlock * * D.27374;
  int D.27375;
  _Bool D.27376;
  long int D.27377;
  long int D.27378;
  short int D.27381;
  unsigned short D.27382;
  unsigned short D.27383;
  short int D.27384;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.25064>;
  <D.25063>:
  D.27333 = from->out_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27336 = D.27333 + D.27335;
  D.27337 = *D.27336;
  if (D.27337 == to) goto <D.27338>; else goto <D.27339>;
  <D.27338>:
  found = 1;
  goto <D.25062>;
  <D.27339>:
  i = i + 1;
  <D.25064>:
  D.27340 = from->out_count;
  D.27341 = (int) D.27340;
  if (D.27341 > i) goto <D.25063>; else goto <D.25062>;
  <D.25062>:
  if (found != 0) goto <D.27342>; else goto <D.27343>;
  <D.27342>:
  pos = 0;
  i = 0;
  goto <D.25066>;
  <D.25065>:
  D.27333 = from->out_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27336 = D.27333 + D.27335;
  D.27337 = *D.27336;
  if (D.27337 != to) goto <D.27344>; else goto <D.27345>;
  <D.27344>:
  D.27333 = from->out_bb;
  pos.14 = pos;
  pos = pos.14 + 1;
  D.27347 = (long unsigned int) pos.14;
  D.27348 = D.27347 * 8;
  D.27349 = D.27333 + D.27348;
  D.27333 = from->out_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27336 = D.27333 + D.27335;
  D.27337 = *D.27336;
  *D.27349 = D.27337;
  <D.27345>:
  i = i + 1;
  <D.25066>:
  D.27340 = from->out_count;
  D.27341 = (int) D.27340;
  if (D.27341 > i) goto <D.25065>; else goto <D.25067>;
  <D.25067>:
  D.27340 = from->out_count;
  D.27341 = (int) D.27340;
  D.27350 = D.27341 + -1;
  D.27351 = D.27350 != pos;
  D.27352 = (long int) D.27351;
  D.27353 = __builtin_expect (D.27352, 0);
  if (D.27353 != 0) goto <D.27354>; else goto <D.27355>;
  <D.27354>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.27355>:
  D.27340 = from->out_count;
  D.27356 = D.27340;
  D.27357 = (unsigned short) D.27356;
  D.27358 = D.27357 + 65535;
  D.27359 = (short int) D.27358;
  from->out_count = D.27359;
  <D.27343>:
  found = 0;
  i = 0;
  goto <D.25070>;
  <D.25069>:
  D.27360 = to->in_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27361 = D.27360 + D.27335;
  D.27362 = *D.27361;
  if (D.27362 == from) goto <D.27363>; else goto <D.27364>;
  <D.27363>:
  found = 1;
  goto <D.25068>;
  <D.27364>:
  i = i + 1;
  <D.25070>:
  D.27365 = to->in_count;
  D.27366 = (int) D.27365;
  if (D.27366 > i) goto <D.25069>; else goto <D.25068>;
  <D.25068>:
  if (found != 0) goto <D.27367>; else goto <D.27368>;
  <D.27367>:
  pos = 0;
  i = 0;
  goto <D.25072>;
  <D.25071>:
  D.27360 = to->in_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27361 = D.27360 + D.27335;
  D.27362 = *D.27361;
  if (D.27362 != from) goto <D.27369>; else goto <D.27370>;
  <D.27369>:
  D.27360 = to->in_bb;
  pos.15 = pos;
  pos = pos.15 + 1;
  D.27372 = (long unsigned int) pos.15;
  D.27373 = D.27372 * 8;
  D.27374 = D.27360 + D.27373;
  D.27360 = to->in_bb;
  D.27334 = (long unsigned int) i;
  D.27335 = D.27334 * 8;
  D.27361 = D.27360 + D.27335;
  D.27362 = *D.27361;
  *D.27374 = D.27362;
  <D.27370>:
  i = i + 1;
  <D.25072>:
  D.27365 = to->in_count;
  D.27366 = (int) D.27365;
  if (D.27366 > i) goto <D.25071>; else goto <D.25073>;
  <D.25073>:
  D.27365 = to->in_count;
  D.27366 = (int) D.27365;
  D.27375 = D.27366 + -1;
  D.27376 = D.27375 != pos;
  D.27377 = (long int) D.27376;
  D.27378 = __builtin_expect (D.27377, 0);
  if (D.27378 != 0) goto <D.27379>; else goto <D.27380>;
  <D.27379>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.27380>:
  D.27365 = to->in_count;
  D.27381 = D.27365;
  D.27382 = (unsigned short) D.27381;
  D.27383 = D.27382 + 65535;
  D.27384 = (short int) D.27383;
  to->in_count = D.27384;
  <D.27368>:
}


mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.27385;
  long unsigned int D.27386;
  long unsigned int D.27387;
  struct MonoBasicBlock * * D.27388;
  struct MonoBasicBlock * D.27389;
  gboolean D.27392;
  short int D.27393;
  int D.27394;
  int i;

  i = 0;
  goto <D.25080>;
  <D.25079>:
  D.27385 = bb1->out_bb;
  D.27386 = (long unsigned int) i;
  D.27387 = D.27386 * 8;
  D.27388 = D.27385 + D.27387;
  D.27389 = *D.27388;
  if (D.27389 == bb2) goto <D.27390>; else goto <D.27391>;
  <D.27390>:
  D.27392 = 1;
  return D.27392;
  <D.27391>:
  i = i + 1;
  <D.25080>:
  D.27393 = bb1->out_count;
  D.27394 = (int) D.27393;
  if (D.27394 > i) goto <D.25079>; else goto <D.25081>;
  <D.25081>:
  D.27392 = 0;
  return D.27392;
}


mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.27396;
  int D.27399;
  int iftmp.16;
  <unnamed-unsigned:15> D.27405;
  int D.27406;
  _Bool D.27407;
  long int D.27408;
  long int D.27409;
  struct MonoExceptionClause * D.27412;
  long unsigned int D.27413;
  long unsigned int D.27414;
  struct MonoExceptionClause * D.27415;
  unsigned int D.27416;
  int D.27417;
  int D.27418;

  D.27396 = region & 240;
  if (D.27396 == 0) goto <D.27397>; else goto <D.27398>;
  <D.27397>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.27399 = region >> 8;
    clause_index = D.27399 + -1;
    if (clause_index < 0) goto <D.27401>; else goto <D.27404>;
    <D.27404>:
    D.27405 = header->num_clauses;
    D.27406 = (int) D.27405;
    if (D.27406 <= clause_index) goto <D.27401>; else goto <D.27402>;
    <D.27401>:
    iftmp.16 = 1;
    goto <D.27403>;
    <D.27402>:
    iftmp.16 = 0;
    <D.27403>:
    D.27407 = iftmp.16 != 0;
    D.27408 = (long int) D.27407;
    D.27409 = __builtin_expect (D.27408, 0);
    if (D.27409 != 0) goto <D.27410>; else goto <D.27411>;
    <D.27410>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.27411>:
    D.27412 = header->clauses;
    D.27413 = (long unsigned int) clause_index;
    D.27414 = D.27413 * 32;
    D.27415 = D.27412 + D.27414;
    D.27416 = D.27415->try_offset;
    D.27417 = (int) D.27416;
    region = mono_find_block_region_notry (cfg, D.27417);
  }
  <D.27398>:
  D.27418 = region;
  return D.27418;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.27420;
  long unsigned int D.27421;
  long unsigned int D.27422;
  unsigned int D.27423;
  unsigned int offset.17;
  unsigned int D.27427;
  unsigned int D.27430;
  int D.27433;
  int D.27434;
  int D.27435;
  unsigned int D.27436;
  unsigned int D.27437;
  unsigned int D.27438;
  unsigned int D.27441;
  unsigned int D.27442;
  unsigned int D.27447;
  unsigned int D.27450;
  unsigned int D.27451;
  <unnamed-unsigned:15> D.27452;
  int D.27453;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.25090>;
  <D.25089>:
  D.27420 = header->clauses;
  D.27421 = (long unsigned int) i;
  D.27422 = D.27421 * 32;
  clause = D.27420 + D.27422;
  D.27423 = clause->flags;
  if (D.27423 == 1) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  offset.17 = (unsigned int) offset;
  D.27427 = clause->data.filter_offset;
  if (offset.17 >= D.27427) goto <D.27428>; else goto <D.27429>;
  <D.27428>:
  offset.17 = (unsigned int) offset;
  D.27430 = clause->handler_offset;
  if (offset.17 < D.27430) goto <D.27431>; else goto <D.27432>;
  <D.27431>:
  D.27434 = i + 1;
  D.27435 = D.27434 << 8;
  D.27436 = (unsigned int) D.27435;
  D.27423 = clause->flags;
  D.27437 = D.27436 | D.27423;
  D.27438 = D.27437 | 128;
  D.27433 = (int) D.27438;
  return D.27433;
  <D.27432>:
  <D.27429>:
  <D.27425>:
  D.27430 = clause->handler_offset;
  offset.17 = (unsigned int) offset;
  if (D.27430 <= offset.17) goto <D.27439>; else goto <D.27440>;
  <D.27439>:
  offset.17 = (unsigned int) offset;
  D.27430 = clause->handler_offset;
  D.27441 = clause->handler_len;
  D.27442 = D.27430 + D.27441;
  if (offset.17 < D.27442) goto <D.27443>; else goto <D.27444>;
  <D.27443>:
  D.27423 = clause->flags;
  if (D.27423 == 2) goto <D.27445>; else goto <D.27446>;
  <D.27445>:
  D.27434 = i + 1;
  D.27435 = D.27434 << 8;
  D.27436 = (unsigned int) D.27435;
  D.27423 = clause->flags;
  D.27437 = D.27436 | D.27423;
  D.27447 = D.27437 | 16;
  D.27433 = (int) D.27447;
  return D.27433;
  <D.27446>:
  D.27423 = clause->flags;
  if (D.27423 == 4) goto <D.27448>; else goto <D.27449>;
  <D.27448>:
  D.27434 = i + 1;
  D.27435 = D.27434 << 8;
  D.27436 = (unsigned int) D.27435;
  D.27423 = clause->flags;
  D.27437 = D.27436 | D.27423;
  D.27450 = D.27437 | 64;
  D.27433 = (int) D.27450;
  return D.27433;
  <D.27449>:
  D.27434 = i + 1;
  D.27435 = D.27434 << 8;
  D.27436 = (unsigned int) D.27435;
  D.27423 = clause->flags;
  D.27437 = D.27436 | D.27423;
  D.27451 = D.27437 | 32;
  D.27433 = (int) D.27451;
  return D.27433;
  <D.27444>:
  <D.27440>:
  i = i + 1;
  <D.25090>:
  D.27452 = header->num_clauses;
  D.27453 = (int) D.27452;
  if (D.27453 > i) goto <D.25089>; else goto <D.25091>;
  <D.25091>:
  D.27433 = -1;
  return D.27433;
}


mono_find_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct MonoInst * D.27455;
  long int D.27456;
  const void * D.27457;
  struct GHashTable * D.27458;

  region = mono_get_block_region_notry (cfg, region);
  D.27456 = (long int) region;
  D.27457 = (const void *) D.27456;
  D.27458 = cfg->spvars;
  D.27455 = monoeg_g_hash_table_lookup (D.27458, D.27457);
  return D.27455;
}


mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.27460;
  int D.27463;
  unsigned int D.27465;
  int D.27468;
  unsigned int D.27470;
  int D.27473;
  unsigned int D.27475;
  int D.27478;
  guint32 D.27480;
  static const int reverse_map[10] = {64, 63, 62, 61, 60, 59, 68, 67, 66, 65};
  static const int reverse_fmap[10] = {667, 666, 665, 664, 663, 662, 671, 670, 669, 668};
  static const int reverse_lmap[10] = {560, 559, 558, 557, 556, 555, 564, 563, 562, 561};
  static const int reverse_imap[10] = {657, 656, 655, 654, 653, 652, 661, 660, 659, 658};

  D.27460 = opcode + 4294967237;
  if (D.27460 <= 9) goto <D.27461>; else goto <D.27462>;
  <D.27461>:
  D.27460 = opcode + 4294967237;
  D.27463 = reverse_map[D.27460];
  opcode = (guint32) D.27463;
  goto <D.27464>;
  <D.27462>:
  D.27465 = opcode + 4294966634;
  if (D.27465 <= 9) goto <D.27466>; else goto <D.27467>;
  <D.27466>:
  D.27465 = opcode + 4294966634;
  D.27468 = reverse_fmap[D.27465];
  opcode = (guint32) D.27468;
  goto <D.27469>;
  <D.27467>:
  D.27470 = opcode + 4294966741;
  if (D.27470 <= 9) goto <D.27471>; else goto <D.27472>;
  <D.27471>:
  D.27470 = opcode + 4294966741;
  D.27473 = reverse_lmap[D.27470];
  opcode = (guint32) D.27473;
  goto <D.27474>;
  <D.27472>:
  D.27475 = opcode + 4294966644;
  if (D.27475 <= 9) goto <D.27476>; else goto <D.27477>;
  <D.27476>:
  D.27475 = opcode + 4294966644;
  D.27478 = reverse_imap[D.27475];
  opcode = (guint32) D.27478;
  goto <D.27479>;
  <D.27477>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.27479>:
  <D.27474>:
  <D.27469>:
  <D.27464>:
  D.27480 = opcode;
  return D.27480;
}


mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.27482;
  unsigned char D.27483;
  guint D.27486;
  unsigned char D.27487;
  int D.27488;
  struct MonoClass * D.27489;
  unsigned char D.27490;
  unsigned char D.27491;
  unsigned int D.27494;
  unsigned int D.27495;
  struct MonoClass * D.27498;
  unsigned char D.27499;
  unsigned char D.27500;
  struct MonoGenericClass * D.27503;
  struct MonoClass * D.27504;
  int D.27505;
  void handle_enum = <<< error >>>;

  D.27482 = BIT_FIELD_REF <*type, 8, 88>;
  D.27483 = D.27482 & 64;
  if (D.27483 != 0) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  D.27486 = 374;
  return D.27486;
  <D.27485>:
  type = mini_replace_type (type);
  handle_enum:
  D.27487 = type->type;
  D.27488 = (int) D.27487;
  switch (D.27488) <default: <D.25150>, case 2: <D.25126>, case 3: <D.25129>, case 4: <D.25124>, case 5: <D.25125>, case 6: <D.25127>, case 7: <D.25128>, case 8: <D.25130>, case 9: <D.25131>, case 10: <D.25141>, case 11: <D.25142>, case 12: <D.25143>, case 13: <D.25144>, case 14: <D.25137>, case 15: <D.25134>, case 17: <D.25145>, case 18: <D.25136>, case 19: <D.25148>, case 20: <D.25140>, case 21: <D.25147>, case 22: <D.25146>, case 24: <D.25132>, case 25: <D.25133>, case 27: <D.25135>, case 28: <D.25138>, case 29: <D.25139>, case 30: <D.25149>>
  <D.25124>:
  <D.25125>:
  <D.25126>:
  D.27486 = 375;
  return D.27486;
  <D.25127>:
  <D.25128>:
  <D.25129>:
  D.27486 = 376;
  return D.27486;
  <D.25130>:
  <D.25131>:
  D.27486 = 377;
  return D.27486;
  <D.25132>:
  <D.25133>:
  <D.25134>:
  <D.25135>:
  D.27486 = 374;
  return D.27486;
  <D.25136>:
  <D.25137>:
  <D.25138>:
  <D.25139>:
  <D.25140>:
  D.27486 = 374;
  return D.27486;
  <D.25141>:
  <D.25142>:
  D.27486 = 378;
  return D.27486;
  <D.25143>:
  D.27486 = 379;
  return D.27486;
  <D.25144>:
  D.27486 = 380;
  return D.27486;
  <D.25145>:
  D.27489 = type->data.klass;
  D.27490 = BIT_FIELD_REF <*D.27489, 8, 256>;
  D.27491 = D.27490 & 16;
  if (D.27491 != 0) goto <D.27492>; else goto <D.27493>;
  <D.27492>:
  D.27489 = type->data.klass;
  type = mono_class_enum_basetype (D.27489);
  goto handle_enum;
  <D.27493>:
  D.27494 = cfg->opt;
  D.27495 = D.27494 & 67108864;
  if (D.27495 != 0) goto <D.27496>; else goto <D.27497>;
  <D.27496>:
  D.27498 = mono_class_from_mono_type (type);
  D.27499 = BIT_FIELD_REF <*D.27498, 8, 288>;
  D.27500 = D.27499 & 2;
  if (D.27500 != 0) goto <D.27501>; else goto <D.27502>;
  <D.27501>:
  D.27486 = 389;
  return D.27486;
  <D.27502>:
  <D.27497>:
  D.27486 = 390;
  return D.27486;
  <D.25146>:
  D.27486 = 390;
  return D.27486;
  <D.25147>:
  D.27503 = type->data.generic_class;
  D.27504 = D.27503->container_class;
  type = &D.27504->byval_arg;
  goto handle_enum;
  <D.25148>:
  <D.25149>:
  D.27505 = mini_type_var_is_vt (cfg, type);
  if (D.27505 != 0) goto <D.27506>; else goto <D.27507>;
  <D.27506>:
  D.27486 = 390;
  return D.27486;
  <D.27507>:
  D.27486 = 374;
  return D.27486;
  <D.25150>:
  D.27487 = type->type;
  D.27488 = (int) D.27487;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.27488);
  <D.25151>:
  goto <D.25151>;
  D.27486 = 4294967295;
  return D.27486;
}


mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.27509;
  unsigned char D.27510;
  guint D.27513;
  unsigned char D.27514;
  int D.27515;
  unsigned int D.27516;
  unsigned int D.27517;
  struct MonoClass * D.27520;
  unsigned char D.27521;
  unsigned char D.27522;
  int D.27525;
  struct MonoGenericSharingContext * D.27528;
  _Bool D.27529;
  long int D.27530;
  long int D.27531;
  int D.27534;

  D.27509 = BIT_FIELD_REF <*type, 8, 88>;
  D.27510 = D.27509 & 64;
  if (D.27510 != 0) goto <D.27511>; else goto <D.27512>;
  <D.27511>:
  D.27513 = 391;
  return D.27513;
  <D.27512>:
  type = mini_replace_type (type);
  D.27514 = type->type;
  D.27515 = (int) D.27514;
  switch (D.27515) <default: <D.25182>, case 2: <D.25158>, case 3: <D.25161>, case 4: <D.25156>, case 5: <D.25157>, case 6: <D.25159>, case 7: <D.25160>, case 8: <D.25162>, case 9: <D.25163>, case 10: <D.25173>, case 11: <D.25174>, case 12: <D.25175>, case 13: <D.25176>, case 14: <D.25169>, case 15: <D.25166>, case 17: <D.25177>, case 18: <D.25168>, case 19: <D.25180>, case 20: <D.25172>, case 21: <D.25179>, case 22: <D.25178>, case 24: <D.25164>, case 25: <D.25165>, case 27: <D.25167>, case 28: <D.25170>, case 29: <D.25171>, case 30: <D.25181>>
  <D.25156>:
  D.27513 = 392;
  return D.27513;
  <D.25157>:
  <D.25158>:
  D.27513 = 393;
  return D.27513;
  <D.25159>:
  D.27513 = 394;
  return D.27513;
  <D.25160>:
  <D.25161>:
  D.27513 = 395;
  return D.27513;
  <D.25162>:
  D.27513 = 396;
  return D.27513;
  <D.25163>:
  D.27513 = 397;
  return D.27513;
  <D.25164>:
  <D.25165>:
  <D.25166>:
  <D.25167>:
  D.27513 = 391;
  return D.27513;
  <D.25168>:
  <D.25169>:
  <D.25170>:
  <D.25171>:
  <D.25172>:
  D.27513 = 391;
  return D.27513;
  <D.25173>:
  <D.25174>:
  D.27513 = 398;
  return D.27513;
  <D.25175>:
  D.27513 = 399;
  return D.27513;
  <D.25176>:
  D.27513 = 400;
  return D.27513;
  <D.25177>:
  D.27516 = cfg->opt;
  D.27517 = D.27516 & 67108864;
  if (D.27517 != 0) goto <D.27518>; else goto <D.27519>;
  <D.27518>:
  D.27520 = mono_class_from_mono_type (type);
  D.27521 = BIT_FIELD_REF <*D.27520, 8, 288>;
  D.27522 = D.27521 & 2;
  if (D.27522 != 0) goto <D.27523>; else goto <D.27524>;
  <D.27523>:
  D.27513 = 401;
  return D.27513;
  <D.27524>:
  <D.27519>:
  <D.25178>:
  D.27513 = 403;
  return D.27513;
  <D.25179>:
  D.27525 = mono_type_generic_inst_is_valuetype (type);
  if (D.27525 != 0) goto <D.27526>; else goto <D.27527>;
  <D.27526>:
  D.27513 = 403;
  return D.27513;
  <D.27527>:
  D.27513 = 391;
  return D.27513;
  <D.25180>:
  <D.25181>:
  D.27528 = cfg->generic_sharing_context;
  D.27529 = D.27528 == 0B;
  D.27530 = (long int) D.27529;
  D.27531 = __builtin_expect (D.27530, 0);
  if (D.27531 != 0) goto <D.27532>; else goto <D.27533>;
  <D.27532>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.27533>:
  D.27534 = mini_type_var_is_vt (cfg, type);
  if (D.27534 != 0) goto <D.27535>; else goto <D.27536>;
  <D.27535>:
  D.27513 = 403;
  return D.27513;
  <D.27536>:
  D.27513 = 391;
  return D.27513;
  <D.25182>:
  D.27514 = type->type;
  D.27515 = (int) D.27514;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.27515);
  <D.25183>:
  goto <D.25183>;
  D.27513 = 4294967295;
  return D.27513;
}


mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27538;
  unsigned char D.27541;
  unsigned char D.27542;
  unsigned char D.27545;
  _Bool D.27546;
  _Bool D.27547;
  _Bool D.27548;
  int D.27551;
  guint D.27554;

  type = mini_replace_type (type);
  D.27538 = cfg->generic_sharing_context;
  if (D.27538 != 0B) goto <D.27539>; else goto <D.27540>;
  <D.27539>:
  D.27541 = BIT_FIELD_REF <*type, 8, 88>;
  D.27542 = D.27541 & 64;
  if (D.27542 == 0) goto <D.27543>; else goto <D.27544>;
  <D.27543>:
  D.27545 = type->type;
  D.27546 = D.27545 == 19;
  D.27547 = D.27545 == 30;
  D.27548 = D.27546 | D.27547;
  if (D.27548 != 0) goto <D.27549>; else goto <D.27550>;
  <D.27549>:
  D.27551 = mini_type_var_is_vt (cfg, type);
  if (D.27551 != 0) goto <D.27552>; else goto <D.27553>;
  <D.27552>:
  D.27554 = 129;
  return D.27554;
  <D.27553>:
  D.27554 = 81;
  return D.27554;
  <D.27550>:
  <D.27544>:
  <D.27540>:
  D.27554 = mono_type_to_stind (type);
  return D.27554;
}


mono_op_imm_to_op (int opcode)
{
  int D.27556;
  const char * D.27557;

  switch (opcode) <default: <D.25231>, case 323: <D.25228>, case 327: <D.25229>, case 339: <D.25230>, case 433: <D.25195>, case 436: <D.25220>, case 438: <D.25221>, case 440: <D.25201>, case 441: <D.25202>, case 442: <D.25203>, case 542: <D.25197>, case 543: <D.25199>, case 545: <D.25205>, case 546: <D.25207>, case 547: <D.25209>, case 548: <D.25211>, case 549: <D.25213>, case 550: <D.25215>, case 624: <D.25226>, case 626: <D.25227>, case 629: <D.25196>, case 630: <D.25198>, case 631: <D.25200>, case 632: <D.25216>, case 633: <D.25217>, case 634: <D.25219>, case 635: <D.25218>, case 636: <D.25204>, case 637: <D.25206>, case 638: <D.25208>, case 639: <D.25210>, case 640: <D.25212>, case 641: <D.25214>, case 756: <D.25223>, case 758: <D.25225>, case 760: <D.25222>, case 762: <D.25224>>
  <D.25195>:
  D.27556 = 483;
  return D.27556;
  <D.25196>:
  D.27556 = 569;
  return D.27556;
  <D.25197>:
  D.27556 = 483;
  return D.27556;
  <D.25198>:
  D.27556 = 570;
  return D.27556;
  <D.25199>:
  D.27556 = 484;
  return D.27556;
  <D.25200>:
  D.27556 = 571;
  return D.27556;
  <D.25201>:
  D.27556 = 490;
  return D.27556;
  <D.25202>:
  D.27556 = 491;
  return D.27556;
  <D.25203>:
  D.27556 = 492;
  return D.27556;
  <D.25204>:
  D.27556 = 576;
  return D.27556;
  <D.25205>:
  D.27556 = 490;
  return D.27556;
  <D.25206>:
  D.27556 = 577;
  return D.27556;
  <D.25207>:
  D.27556 = 491;
  return D.27556;
  <D.25208>:
  D.27556 = 578;
  return D.27556;
  <D.25209>:
  D.27556 = 492;
  return D.27556;
  <D.25210>:
  D.27556 = 579;
  return D.27556;
  <D.25211>:
  D.27556 = 493;
  return D.27556;
  <D.25212>:
  D.27556 = 580;
  return D.27556;
  <D.25213>:
  D.27556 = 494;
  return D.27556;
  <D.25214>:
  D.27556 = 581;
  return D.27556;
  <D.25215>:
  D.27556 = 495;
  return D.27556;
  <D.25216>:
  D.27556 = 572;
  return D.27556;
  <D.25217>:
  D.27556 = 573;
  return D.27556;
  <D.25218>:
  D.27556 = 575;
  return D.27556;
  <D.25219>:
  D.27556 = 574;
  return D.27556;
  <D.25220>:
  D.27556 = 486;
  return D.27556;
  <D.25221>:
  D.27556 = 488;
  return D.27556;
  <D.25222>:
  D.27556 = 759;
  return D.27556;
  <D.25223>:
  D.27556 = 755;
  return D.27556;
  <D.25224>:
  D.27556 = 761;
  return D.27556;
  <D.25225>:
  D.27556 = 757;
  return D.27556;
  <D.25226>:
  D.27556 = 623;
  return D.27556;
  <D.25227>:
  D.27556 = 625;
  return D.27556;
  <D.25228>:
  D.27556 = 322;
  return D.27556;
  <D.25229>:
  D.27556 = 326;
  return D.27556;
  <D.25230>:
  D.27556 = 338;
  return D.27556;
  <D.25231>:
  D.27557 = mono_inst_name (opcode);
  printf ("%s\n", D.27557);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.27556 = -1;
  return D.27556;
}


mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.27559;
  long int D.27560;
  struct MonoInst * D.27561;
  int D.27562;
  int D.27563;
  const unsigned char * D.27564;
  long int D.27565;
  unsigned int D.27566;
  int D.27567;
  short unsigned int D.27568;
  int D.27569;
  int D.27570;
  short unsigned int D.27571;
  int D.27574;
  unsigned int D.27576;
  unsigned int D.27577;
  unsigned int D.27578;
  struct MonoInst * temp;

  D.27559 = cfg->mempool;
  temp = mono_mempool_alloc (D.27559, 80);
  temp->data.op[1].const_val = 0;
  D.27560 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.27560;
  temp->prev = 0B;
  D.27561 = temp->prev;
  temp->next = D.27561;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.27562 = temp->sreg3;
  temp->sreg2 = D.27562;
  D.27563 = temp->sreg2;
  temp->sreg1 = D.27563;
  D.27564 = cfg->ip;
  temp->cil_code = D.27564;
  D.27565 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.27565;
  D.27566 = mono_alloc_ireg (cfg);
  D.27567 = (int) D.27566;
  temp->dreg = D.27567;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.27568 = ins->opcode;
  D.27569 = (int) D.27568;
  D.27570 = mono_op_imm_to_op (D.27569);
  D.27571 = (short unsigned int) D.27570;
  ins->opcode = D.27571;
  D.27568 = ins->opcode;
  if (D.27568 == 338) goto <D.27572>; else goto <D.27573>;
  <D.27572>:
  D.27574 = temp->dreg;
  ins->sreg1 = D.27574;
  goto <D.27575>;
  <D.27573>:
  D.27574 = temp->dreg;
  ins->sreg2 = D.27574;
  <D.27575>:
  D.27576 = cfg->next_vreg;
  D.27577 = bb->max_vreg;
  D.27578 = MAX_EXPR <D.27576, D.27577>;
  bb->max_vreg = D.27578;
}


mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.27579;
  int D.27580;
  unsigned int D.27581;
  unsigned int D.27582;
  guint iftmp.18;
  long unsigned int D.27589;
  long unsigned int D.27590;
  struct MonoInst * * D.27591;
  void * D.27592;
  long unsigned int D.27593;
  struct MonoMethodVar * D.27594;
  void * D.27595;
  unsigned int orig_count.19;
  unsigned int D.27597;
  long unsigned int D.27598;
  long unsigned int D.27599;
  long unsigned int D.27600;
  long unsigned int D.27601;
  void * D.27602;
  int D.27603;
  int D.27604;
  struct MonoMemPool * D.27605;
  long int D.27606;
  struct MonoInst * D.27607;
  short unsigned int D.27608;
  int D.27609;
  int D.27610;
  const unsigned char * D.27611;
  long int D.27612;
  struct MonoClass * D.27613;
  struct MonoClass * D.27614;
  unsigned char D.27615;
  unsigned char D.27618;
  unsigned char D.27619;
  unsigned char D.27622;
  unsigned char D.27623;
  int D.27630;
  unsigned char D.27632;
  unsigned char D.27633;
  int D.27634;
  unsigned char D.27635;
  unsigned char D.27636;
  long unsigned int D.27637;
  long unsigned int D.27638;
  struct MonoInst * * D.27639;
  long unsigned int D.27640;
  struct MonoMethodVar * D.27641;
  unsigned int num.20;
  unsigned int D.27647;
  int D.27650;
  int D.27651;
  int D.27652;
  int D.27653;
  unsigned int D.27656;
  unsigned int D.27657;
  unsigned char D.27662;
  unsigned char D.27663;
  long int D.27666;
  struct MonoInst * D.27667;
  int D.27668;
  int D.27669;
  struct MonoClass * D.27672;
  struct MonoType * D.27673;
  struct MonoType * D.27674;
  struct MonoClass * D.27675;
  struct MonoClass * D.27678;
  unsigned int D.27679;
  char * D.27682;
  struct MonoInst * D.27683;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.27579 = cfg->num_varinfo;
  num = (int) D.27579;
  type = mini_replace_type (type);
  D.27580 = num + 1;
  D.27581 = (unsigned int) D.27580;
  D.27582 = cfg->varinfo_count;
  if (D.27581 >= D.27582) goto <D.27583>; else goto <D.27584>;
  <D.27583>:
  {
    int orig_count;

    D.27582 = cfg->varinfo_count;
    orig_count = (int) D.27582;
    D.27582 = cfg->varinfo_count;
    if (D.27582 != 0) goto <D.27586>; else goto <D.27587>;
    <D.27586>:
    D.27582 = cfg->varinfo_count;
    iftmp.18 = D.27582 * 2;
    goto <D.27588>;
    <D.27587>:
    iftmp.18 = 64;
    <D.27588>:
    cfg->varinfo_count = iftmp.18;
    D.27582 = cfg->varinfo_count;
    D.27589 = (long unsigned int) D.27582;
    D.27590 = D.27589 * 8;
    D.27591 = cfg->varinfo;
    D.27592 = monoeg_realloc (D.27591, D.27590);
    cfg->varinfo = D.27592;
    D.27582 = cfg->varinfo_count;
    D.27589 = (long unsigned int) D.27582;
    D.27593 = D.27589 * 80;
    D.27594 = cfg->vars;
    D.27595 = monoeg_realloc (D.27594, D.27593);
    cfg->vars = D.27595;
    D.27582 = cfg->varinfo_count;
    orig_count.19 = (unsigned int) orig_count;
    D.27597 = D.27582 - orig_count.19;
    D.27598 = (long unsigned int) D.27597;
    D.27599 = D.27598 * 80;
    D.27594 = cfg->vars;
    D.27600 = (long unsigned int) orig_count;
    D.27601 = D.27600 * 80;
    D.27602 = D.27594 + D.27601;
    memset (D.27602, 0, D.27599);
  }
  <D.27584>:
  D.27603 = cfg->stat_allocate_var;
  D.27604 = D.27603 + 1;
  cfg->stat_allocate_var = D.27604;
  D.27605 = cfg->mempool;
  inst = mono_mempool_alloc (D.27605, 80);
  inst->data.op[1].const_val = 0;
  D.27606 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.27606;
  inst->prev = 0B;
  D.27607 = inst->prev;
  inst->next = D.27607;
  D.27608 = (short unsigned int) opcode;
  inst->opcode = D.27608;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.27609 = inst->sreg3;
  inst->sreg2 = D.27609;
  D.27610 = inst->sreg2;
  inst->sreg1 = D.27610;
  D.27611 = cfg->ip;
  inst->cil_code = D.27611;
  D.27612 = (long int) num;
  inst->data.op[0].const_val = D.27612;
  inst->data.op[1].vtype = type;
  D.27613 = mono_class_from_mono_type (type);
  inst->klass = D.27613;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.27614 = inst->klass;
  D.27615 = D.27614->exception_type;
  if (D.27615 != 0) goto <D.27616>; else goto <D.27617>;
  <D.27616>:
  mono_cfg_set_exception (cfg, 7);
  <D.27617>:
  D.27618 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.27619 = D.27618 & 128;
  if (D.27619 != 0) goto <D.27620>; else goto <D.27621>;
  <D.27620>:
  D.27622 = BIT_FIELD_REF <*type, 8, 88>;
  D.27623 = D.27622 & 64;
  if (D.27623 != 0) goto <D.27624>; else goto <D.27625>;
  <D.27624>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.27626>;
  <D.27625>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.27630 = mono_type_is_struct (t);
    if (D.27630 != 0) goto <D.27631>; else goto <D.27627>;
    <D.27631>:
    D.27614 = inst->klass;
    D.27632 = BIT_FIELD_REF <*D.27614, 8, 280>;
    D.27633 = D.27632 & 8;
    if (D.27633 != 0) goto <D.27628>; else goto <D.27627>;
    <D.27627>:
    D.27634 = mini_type_is_reference (cfg, t);
    if (D.27634 != 0) goto <D.27628>; else goto <D.27629>;
    <D.27628>:
    D.27635 = inst->flags;
    D.27636 = D.27635 | 128;
    inst->flags = D.27636;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.27629>:
  }
  <D.27626>:
  <D.27621>:
  D.27591 = cfg->varinfo;
  D.27637 = (long unsigned int) num;
  D.27638 = D.27637 * 8;
  D.27639 = D.27591 + D.27638;
  *D.27639 = inst;
  D.27594 = cfg->vars;
  D.27637 = (long unsigned int) num;
  D.27640 = D.27637 * 80;
  D.27641 = D.27594 + D.27640;
  D.27641->range.first_use.pos.bid = 65535;
  D.27594 = cfg->vars;
  D.27637 = (long unsigned int) num;
  D.27640 = D.27637 * 80;
  D.27641 = D.27594 + D.27640;
  D.27641->reg = -1;
  D.27594 = cfg->vars;
  D.27637 = (long unsigned int) num;
  D.27640 = D.27637 * 80;
  D.27641 = D.27594 + D.27640;
  num.20 = (unsigned int) num;
  D.27641->idx = num.20;
  D.27594 = cfg->vars;
  D.27637 = (long unsigned int) num;
  D.27640 = D.27637 * 80;
  D.27641 = D.27594 + D.27640;
  D.27641->vreg = vreg;
  if (vreg != -1) goto <D.27643>; else goto <D.27644>;
  <D.27643>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.27644>:
  regpair = 0;
  if (regpair != 0) goto <D.27645>; else goto <D.27646>;
  <D.27645>:
  {
    struct MonoInst * tree;

    D.27647 = cfg->verbose_level;
    if (D.27647 > 3) goto <D.27648>; else goto <D.27649>;
    <D.27648>:
    D.27650 = inst->dreg;
    D.27651 = D.27650 + 2;
    D.27650 = inst->dreg;
    D.27652 = D.27650 + 1;
    D.27650 = inst->dreg;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.27650, D.27652, D.27651);
    <D.27649>:
    D.27653 = mono_arch_is_soft_float ();
    if (D.27653 != 0) goto <D.27654>; else goto <D.27655>;
    <D.27654>:
    D.27656 = cfg->opt;
    D.27657 = D.27656 & 2097152;
    if (D.27657 != 0) goto <D.27658>; else goto <D.27659>;
    <D.27658>:
    D.27622 = BIT_FIELD_REF <*type, 8, 88>;
    D.27623 = D.27622 & 64;
    if (D.27623 == 0) goto <D.27660>; else goto <D.27661>;
    <D.27660>:
    D.27662 = type->type;
    D.27663 = D.27662 + 244;
    if (D.27663 <= 1) goto <D.27664>; else goto <D.27665>;
    <D.27664>:
    inst->flags = 4;
    <D.27665>:
    <D.27661>:
    <D.27659>:
    <D.27655>:
    D.27605 = cfg->mempool;
    tree = mono_mempool_alloc (D.27605, 80);
    tree->data.op[1].const_val = 0;
    D.27666 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27666;
    tree->prev = 0B;
    D.27667 = tree->prev;
    tree->next = D.27667;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27668 = tree->sreg3;
    tree->sreg2 = D.27668;
    D.27669 = tree->sreg2;
    tree->sreg1 = D.27669;
    D.27611 = cfg->ip;
    tree->cil_code = D.27611;
    D.27650 = inst->dreg;
    D.27652 = D.27650 + 1;
    tree->dreg = D.27652;
    D.27656 = cfg->opt;
    D.27657 = D.27656 & 2097152;
    if (D.27657 != 0) goto <D.27670>; else goto <D.27671>;
    <D.27670>:
    tree->flags = 4;
    <D.27671>:
    D.27612 = (long int) num;
    tree->data.op[0].const_val = D.27612;
    tree->type = 1;
    D.27672 = mono_defaults.int32_class;
    D.27673 = &D.27672->byval_arg;
    tree->data.op[1].vtype = D.27673;
    D.27674 = tree->data.op[1].vtype;
    D.27675 = mono_class_from_mono_type (D.27674);
    tree->klass = D.27675;
    D.27650 = inst->dreg;
    D.27652 = D.27650 + 1;
    set_vreg_to_inst (cfg, D.27652, tree);
    D.27605 = cfg->mempool;
    tree = mono_mempool_alloc (D.27605, 80);
    tree->data.op[1].const_val = 0;
    D.27666 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27666;
    tree->prev = 0B;
    D.27667 = tree->prev;
    tree->next = D.27667;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27668 = tree->sreg3;
    tree->sreg2 = D.27668;
    D.27669 = tree->sreg2;
    tree->sreg1 = D.27669;
    D.27611 = cfg->ip;
    tree->cil_code = D.27611;
    D.27650 = inst->dreg;
    D.27651 = D.27650 + 2;
    tree->dreg = D.27651;
    D.27656 = cfg->opt;
    D.27657 = D.27656 & 2097152;
    if (D.27657 != 0) goto <D.27676>; else goto <D.27677>;
    <D.27676>:
    tree->flags = 4;
    <D.27677>:
    D.27612 = (long int) num;
    tree->data.op[0].const_val = D.27612;
    tree->type = 1;
    D.27672 = mono_defaults.int32_class;
    D.27673 = &D.27672->byval_arg;
    tree->data.op[1].vtype = D.27673;
    D.27674 = tree->data.op[1].vtype;
    D.27678 = mono_class_from_mono_type (D.27674);
    tree->klass = D.27678;
    D.27650 = inst->dreg;
    D.27651 = D.27650 + 2;
    set_vreg_to_inst (cfg, D.27651, tree);
  }
  <D.27646>:
  D.27579 = cfg->num_varinfo;
  D.27679 = D.27579 + 1;
  cfg->num_varinfo = D.27679;
  D.27647 = cfg->verbose_level;
  if (D.27647 > 2) goto <D.27680>; else goto <D.27681>;
  <D.27680>:
  D.27682 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.27682);
  <D.27681>:
  D.27683 = inst;
  return D.27683;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27687;
  int D.27692;
  void * D.27694;
  long unsigned int D.27695;

  D.27687 = __builtin_constant_p (__len);
  if (D.27687 != 0) goto <D.27688>; else goto <D.27689>;
  <D.27688>:
  if (__len == 0) goto <D.27690>; else goto <D.27691>;
  <D.27690>:
  D.27692 = __builtin_constant_p (__ch);
  if (D.27692 == 0) goto <D.27685>; else goto <D.27693>;
  <D.27693>:
  if (__ch != 0) goto <D.27685>; else goto <D.27686>;
  <D.27685>:
  __warn_memset_zero_len ();
  D.27694 = __dest;
  return D.27694;
  <D.27686>:
  <D.27691>:
  <D.27689>:
  D.27695 = __builtin_object_size (__dest, 0);
  D.27694 = __builtin___memset_chk (__dest, __ch, __len, D.27695);
  return D.27694;
}


mono_arch_is_soft_float ()
{
  gboolean D.27697;

  D.27697 = 0;
  return D.27697;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int vreg.21;
  unsigned int D.27700;
  guint32 iftmp.22;
  unsigned int D.27707;
  struct MonoMemPool * D.27708;
  void * D.27709;
  long unsigned int D.27712;
  long unsigned int D.27713;
  struct MonoInst * * D.27714;
  long unsigned int D.27715;
  long unsigned int D.27716;
  struct MonoInst * * D.27717;

  vreg.21 = (unsigned int) vreg;
  D.27700 = cfg->vreg_to_inst_len;
  if (vreg.21 >= D.27700) goto <D.27701>; else goto <D.27702>;
  <D.27701>:
  {
    struct MonoInst * * tmp;
    int size;

    tmp = cfg->vreg_to_inst;
    D.27700 = cfg->vreg_to_inst_len;
    size = (int) D.27700;
    goto <D.25246>;
    <D.25245>:
    D.27700 = cfg->vreg_to_inst_len;
    if (D.27700 != 0) goto <D.27704>; else goto <D.27705>;
    <D.27704>:
    D.27700 = cfg->vreg_to_inst_len;
    iftmp.22 = D.27700 * 2;
    goto <D.27706>;
    <D.27705>:
    iftmp.22 = 32;
    <D.27706>:
    cfg->vreg_to_inst_len = iftmp.22;
    <D.25246>:
    vreg.21 = (unsigned int) vreg;
    D.27700 = cfg->vreg_to_inst_len;
    if (vreg.21 >= D.27700) goto <D.25245>; else goto <D.25247>;
    <D.25247>:
    D.27700 = cfg->vreg_to_inst_len;
    D.27707 = D.27700 * 8;
    D.27708 = cfg->mempool;
    D.27709 = mono_mempool_alloc0 (D.27708, D.27707);
    cfg->vreg_to_inst = D.27709;
    if (size != 0) goto <D.27710>; else goto <D.27711>;
    <D.27710>:
    D.27712 = (long unsigned int) size;
    D.27713 = D.27712 * 8;
    D.27714 = cfg->vreg_to_inst;
    memcpy (D.27714, tmp, D.27713);
    <D.27711>:
  }
  <D.27702>:
  D.27714 = cfg->vreg_to_inst;
  D.27715 = (long unsigned int) vreg;
  D.27716 = D.27715 * 8;
  D.27717 = D.27714 + D.27716;
  *D.27717 = inst;
}


mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  unsigned char D.27721;
  unsigned char D.27722;
  struct MonoType * D.27724;
  unsigned char D.27725;
  struct MonoType * D.27727;
  unsigned char D.27728;
  unsigned int D.27729;
  int D.27732;
  unsigned char D.27735;
  unsigned char D.27736;
  unsigned int D.27738;
  unsigned int D.27739;
  struct MonoInst * D.27740;
  int dreg;

  type = mini_replace_type (type);
  D.27721 = BIT_FIELD_REF <*type, 8, 88>;
  D.27722 = D.27721 & 64;
  if (D.27722 == 0) goto <D.27723>; else goto <D.27718>;
  <D.27723>:
  D.27724 = mono_type_get_underlying_type (type);
  D.27725 = D.27724->type;
  if (D.27725 == 10) goto <D.27719>; else goto <D.27726>;
  <D.27726>:
  D.27727 = mono_type_get_underlying_type (type);
  D.27728 = D.27727->type;
  if (D.27728 == 11) goto <D.27719>; else goto <D.27718>;
  <D.27719>:
  D.27729 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.27729;
  goto <D.27720>;
  <D.27718>:
  D.27732 = mono_arch_is_soft_float ();
  if (D.27732 != 0) goto <D.27733>; else goto <D.27730>;
  <D.27733>:
  D.27721 = BIT_FIELD_REF <*type, 8, 88>;
  D.27722 = D.27721 & 64;
  if (D.27722 == 0) goto <D.27734>; else goto <D.27730>;
  <D.27734>:
  D.27735 = type->type;
  D.27736 = D.27735 + 244;
  if (D.27736 <= 1) goto <D.27737>; else goto <D.27730>;
  <D.27737>:
  D.27738 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.27738;
  goto <D.27731>;
  <D.27730>:
  D.27739 = mono_alloc_preg (cfg);
  dreg = (int) D.27739;
  <D.27731>:
  <D.27720>:
  D.27740 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.27740;
}


mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.27742;
  long unsigned int var_index.23;
  long unsigned int D.27744;
  struct MonoInst * * D.27745;
  struct MonoInst * D.27746;
  struct MonoInst * D.27747;
  struct MonoType * D.27748;
  unsigned int D.27749;
  short unsigned int D.27750;
  struct MonoClass * D.27751;

  memset (dest, 0, 80);
  D.27742 = cfg->varinfo;
  var_index.23 = (long unsigned int) var_index;
  D.27744 = var_index.23 * 8;
  D.27745 = D.27742 + D.27744;
  D.27746 = *D.27745;
  dest->data.op[0].src = D.27746;
  D.27747 = dest->data.op[0].src;
  D.27748 = D.27747->data.op[1].vtype;
  D.27749 = mini_type_to_ldind (cfg, D.27748);
  D.27750 = (short unsigned int) D.27749;
  dest->opcode = D.27750;
  D.27747 = dest->data.op[0].src;
  D.27748 = D.27747->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.27748, dest);
  D.27747 = dest->data.op[0].src;
  D.27751 = D.27747->klass;
  dest->klass = D.27751;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27752;
  unsigned char D.27755;
  unsigned char D.27756;
  unsigned char D.27759;
  _Bool D.27760;
  _Bool D.27761;
  _Bool D.27762;
  int D.27765;
  guint D.27768;

  D.27752 = cfg->generic_sharing_context;
  if (D.27752 != 0B) goto <D.27753>; else goto <D.27754>;
  <D.27753>:
  D.27755 = BIT_FIELD_REF <*type, 8, 88>;
  D.27756 = D.27755 & 64;
  if (D.27756 == 0) goto <D.27757>; else goto <D.27758>;
  <D.27757>:
  D.27759 = type->type;
  D.27760 = D.27759 == 19;
  D.27761 = D.27759 == 30;
  D.27762 = D.27760 | D.27761;
  if (D.27762 != 0) goto <D.27763>; else goto <D.27764>;
  <D.27763>:
  D.27765 = mini_type_var_is_vt (cfg, type);
  if (D.27765 != 0) goto <D.27766>; else goto <D.27767>;
  <D.27766>:
  D.27768 = 113;
  return D.27768;
  <D.27767>:
  D.27768 = 80;
  return D.27768;
  <D.27764>:
  <D.27758>:
  <D.27754>:
  D.27768 = mono_type_to_ldind (type);
  return D.27768;
}


mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.24;
  unsigned int D.27771;
  guint32 iftmp.25;
  unsigned int D.27778;
  struct MonoMemPool * D.27779;
  void * D.27780;
  long unsigned int D.27783;
  long unsigned int D.27784;
  gboolean * D.27785;
  long unsigned int D.27786;
  long unsigned int D.27787;
  gboolean * D.27788;

  vreg.24 = (unsigned int) vreg;
  D.27771 = cfg->vreg_is_ref_len;
  if (vreg.24 >= D.27771) goto <D.27772>; else goto <D.27773>;
  <D.27772>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_ref;
    D.27771 = cfg->vreg_is_ref_len;
    size = (int) D.27771;
    goto <D.25278>;
    <D.25277>:
    D.27771 = cfg->vreg_is_ref_len;
    if (D.27771 != 0) goto <D.27775>; else goto <D.27776>;
    <D.27775>:
    D.27771 = cfg->vreg_is_ref_len;
    iftmp.25 = D.27771 * 2;
    goto <D.27777>;
    <D.27776>:
    iftmp.25 = 32;
    <D.27777>:
    cfg->vreg_is_ref_len = iftmp.25;
    <D.25278>:
    vreg.24 = (unsigned int) vreg;
    D.27771 = cfg->vreg_is_ref_len;
    if (vreg.24 >= D.27771) goto <D.25277>; else goto <D.25279>;
    <D.25279>:
    D.27771 = cfg->vreg_is_ref_len;
    D.27778 = D.27771 * 4;
    D.27779 = cfg->mempool;
    D.27780 = mono_mempool_alloc0 (D.27779, D.27778);
    cfg->vreg_is_ref = D.27780;
    if (size != 0) goto <D.27781>; else goto <D.27782>;
    <D.27781>:
    D.27783 = (long unsigned int) size;
    D.27784 = D.27783 * 4;
    D.27785 = cfg->vreg_is_ref;
    memcpy (D.27785, tmp, D.27784);
    <D.27782>:
  }
  <D.27773>:
  D.27785 = cfg->vreg_is_ref;
  D.27786 = (long unsigned int) vreg;
  D.27787 = D.27786 * 4;
  D.27788 = D.27785 + D.27787;
  *D.27788 = 1;
}


mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.26;
  unsigned int D.27790;
  guint32 iftmp.27;
  unsigned int D.27797;
  struct MonoMemPool * D.27798;
  void * D.27799;
  long unsigned int D.27802;
  long unsigned int D.27803;
  gboolean * D.27804;
  long unsigned int D.27805;
  long unsigned int D.27806;
  gboolean * D.27807;

  vreg.26 = (unsigned int) vreg;
  D.27790 = cfg->vreg_is_mp_len;
  if (vreg.26 >= D.27790) goto <D.27791>; else goto <D.27792>;
  <D.27791>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_mp;
    D.27790 = cfg->vreg_is_mp_len;
    size = (int) D.27790;
    goto <D.25287>;
    <D.25286>:
    D.27790 = cfg->vreg_is_mp_len;
    if (D.27790 != 0) goto <D.27794>; else goto <D.27795>;
    <D.27794>:
    D.27790 = cfg->vreg_is_mp_len;
    iftmp.27 = D.27790 * 2;
    goto <D.27796>;
    <D.27795>:
    iftmp.27 = 32;
    <D.27796>:
    cfg->vreg_is_mp_len = iftmp.27;
    <D.25287>:
    vreg.26 = (unsigned int) vreg;
    D.27790 = cfg->vreg_is_mp_len;
    if (vreg.26 >= D.27790) goto <D.25286>; else goto <D.25288>;
    <D.25288>:
    D.27790 = cfg->vreg_is_mp_len;
    D.27797 = D.27790 * 4;
    D.27798 = cfg->mempool;
    D.27799 = mono_mempool_alloc0 (D.27798, D.27797);
    cfg->vreg_is_mp = D.27799;
    if (size != 0) goto <D.27800>; else goto <D.27801>;
    <D.27800>:
    D.27802 = (long unsigned int) size;
    D.27803 = D.27802 * 4;
    D.27804 = cfg->vreg_is_mp;
    memcpy (D.27804, tmp, D.27803);
    <D.27801>:
  }
  <D.27792>:
  D.27804 = cfg->vreg_is_mp;
  D.27805 = (long unsigned int) vreg;
  D.27806 = D.27805 * 4;
  D.27807 = D.27804 + D.27806;
  *D.27807 = 1;
}


mono_type_from_stack_type (struct MonoInst * ins)
{
  struct MonoType * D.27808;

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


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.27810;
  int D.27811;
  struct MonoType * D.27812;
  struct MonoClass * D.27813;
  struct MonoClass * D.27814;
  struct MonoClass * D.27815;
  struct MonoClass * D.27816;
  struct MonoClass * D.27817;
  struct MonoClass * D.27820;
  unsigned char D.27823;
  unsigned char D.27824;

  D.27810 = ins->type;
  D.27811 = (int) D.27810;
  switch (D.27811) <default: <D.25299>, case 1: <D.25292>, case 2: <D.25293>, case 3: <D.25294>, case 4: <D.25295>, case 5: <D.25296>, case 6: <D.25297>, case 7: <D.25298>>
  <D.25292>:
  D.27813 = mono_defaults.int32_class;
  D.27812 = &D.27813->byval_arg;
  return D.27812;
  <D.25293>:
  D.27814 = mono_defaults.int64_class;
  D.27812 = &D.27814->byval_arg;
  return D.27812;
  <D.25294>:
  D.27815 = mono_defaults.int_class;
  D.27812 = &D.27815->byval_arg;
  return D.27812;
  <D.25295>:
  D.27816 = mono_defaults.double_class;
  D.27812 = &D.27816->byval_arg;
  return D.27812;
  <D.25296>:
  D.27817 = ins->klass;
  if (D.27817 != 0B) goto <D.27818>; else goto <D.27819>;
  <D.27818>:
  D.27817 = ins->klass;
  D.27812 = &D.27817->this_arg;
  return D.27812;
  <D.27819>:
  D.27820 = mono_defaults.object_class;
  D.27812 = &D.27820->this_arg;
  return D.27812;
  <D.25297>:
  D.27817 = ins->klass;
  if (D.27817 != 0B) goto <D.27821>; else goto <D.27822>;
  <D.27821>:
  D.27817 = ins->klass;
  D.27823 = BIT_FIELD_REF <*D.27817, 8, 256>;
  D.27824 = D.27823 & 8;
  if (D.27824 == 0) goto <D.27825>; else goto <D.27826>;
  <D.27825>:
  D.27817 = ins->klass;
  D.27812 = &D.27817->byval_arg;
  return D.27812;
  <D.27826>:
  <D.27822>:
  D.27820 = mono_defaults.object_class;
  D.27812 = &D.27820->byval_arg;
  return D.27812;
  <D.25298>:
  D.27817 = ins->klass;
  D.27812 = &D.27817->byval_arg;
  return D.27812;
  <D.25299>:
  D.27810 = ins->type;
  D.27811 = (int) D.27810;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.27811);
  <D.25300>:
  goto <D.25300>;
  D.27812 = 0B;
  return D.27812;
}


mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.27828;
  struct MonoInst * D.27831;
  short unsigned int D.27835;
  int D.27836;
  short unsigned int D.27840;
  short unsigned int D.27841;
  _Bool D.27842;
  short unsigned int D.27843;
  _Bool D.27844;
  _Bool D.27845;
  short unsigned int D.27847;
  struct MonoInst * D.27850;
  short unsigned int D.27853;
  unsigned int opcode.28;
  unsigned int D.27858;
  _Bool D.27859;
  _Bool D.27860;
  _Bool D.27861;
  _Bool D.27863;
  _Bool D.27864;
  _Bool D.27865;
  _Bool D.27867;
  _Bool D.27868;
  _Bool D.27869;
  struct MonoInst * D.27871;
  short unsigned int D.27872;
  int opcode;

  D.27828 = bb->code;
  if (D.27828 == 0B) goto <D.27829>; else goto <D.27830>;
  <D.27829>:
  D.27831 = bb->last_ins;
  if (D.27831 != 0B) goto <D.27832>; else goto <D.27833>;
  <D.27832>:
  D.27831 = bb->last_ins;
  D.27831->next = inst;
  D.27831 = bb->last_ins;
  inst->prev = D.27831;
  bb->last_ins = inst;
  goto <D.27834>;
  <D.27833>:
  bb->last_ins = inst;
  D.27831 = bb->last_ins;
  bb->code = D.27831;
  <D.27834>:
  return;
  <D.27830>:
  D.27831 = bb->last_ins;
  D.27835 = D.27831->opcode;
  D.27836 = (int) D.27835;
  switch (D.27836) <default: <D.25323>, case 59: <D.25311>, case 60: <D.25312>, case 61: <D.25313>, case 62: <D.25314>, case 63: <D.25315>, case 64: <D.25316>, case 65: <D.25317>, case 66: <D.25318>, case 67: <D.25319>, case 68: <D.25320>, case 370: <D.25321>, case 446: <D.25309>, case 763: <D.25310>>
  <D.25309>:
  <D.25310>:
  <D.25311>:
  <D.25312>:
  <D.25313>:
  <D.25314>:
  <D.25315>:
  <D.25316>:
  <D.25317>:
  <D.25318>:
  <D.25319>:
  <D.25320>:
  <D.25321>:
  D.27831 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27831, inst);
  goto <D.25322>;
  <D.25323>:
  D.27831 = bb->last_ins;
  D.27840 = D.27831->opcode;
  D.27841 = D.27840 + 64981;
  D.27842 = D.27841 <= 9;
  D.27843 = D.27840 + 64874;
  D.27844 = D.27843 <= 9;
  D.27845 = D.27842 | D.27844;
  if (D.27845 != 0) goto <D.27837>; else goto <D.27846>;
  <D.27846>:
  D.27831 = bb->last_ins;
  D.27835 = D.27831->opcode;
  D.27847 = D.27835 + 64884;
  if (D.27847 <= 9) goto <D.27837>; else goto <D.27838>;
  <D.27837>:
  D.27828 = bb->code;
  D.27831 = bb->last_ins;
  if (D.27828 == D.27831) goto <D.27848>; else goto <D.27849>;
  <D.27848>:
  D.27831 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27831, inst);
  return;
  <D.27849>:
  D.27828 = bb->code;
  D.27850 = D.27828->next;
  D.27831 = bb->last_ins;
  if (D.27850 == D.27831) goto <D.27851>; else goto <D.27852>;
  <D.27851>:
  D.27828 = bb->code;
  D.27853 = D.27828->opcode;
  opcode = (int) D.27853;
  opcode.28 = (unsigned int) opcode;
  D.27858 = opcode.28 + 4294966974;
  D.27859 = D.27858 <= 1;
  D.27860 = opcode == 326;
  D.27861 = D.27859 | D.27860;
  if (D.27861 != 0) goto <D.27854>; else goto <D.27862>;
  <D.27862>:
  D.27863 = opcode == 327;
  D.27864 = opcode == 324;
  D.27865 = D.27863 | D.27864;
  if (D.27865 != 0) goto <D.27854>; else goto <D.27866>;
  <D.27866>:
  D.27867 = opcode == 325;
  D.27868 = opcode == 328;
  D.27869 = D.27867 | D.27868;
  if (D.27869 != 0) goto <D.27854>; else goto <D.27855>;
  <D.27854>:
  D.27828 = bb->code;
  mono_bblock_insert_before_ins (bb, D.27828, inst);
  goto <D.27856>;
  <D.27855>:
  D.27831 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27831, inst);
  <D.27856>:
  goto <D.27870>;
  <D.27852>:
  D.27831 = bb->last_ins;
  D.27871 = D.27831->prev;
  D.27872 = D.27871->opcode;
  opcode = (int) D.27872;
  opcode.28 = (unsigned int) opcode;
  D.27858 = opcode.28 + 4294966974;
  D.27859 = D.27858 <= 1;
  D.27860 = opcode == 326;
  D.27861 = D.27859 | D.27860;
  if (D.27861 != 0) goto <D.27873>; else goto <D.27876>;
  <D.27876>:
  D.27863 = opcode == 327;
  D.27864 = opcode == 324;
  D.27865 = D.27863 | D.27864;
  if (D.27865 != 0) goto <D.27873>; else goto <D.27877>;
  <D.27877>:
  D.27867 = opcode == 325;
  D.27868 = opcode == 328;
  D.27869 = D.27867 | D.27868;
  if (D.27869 != 0) goto <D.27873>; else goto <D.27874>;
  <D.27873>:
  D.27831 = bb->last_ins;
  D.27871 = D.27831->prev;
  mono_bblock_insert_before_ins (bb, D.27871, inst);
  goto <D.27875>;
  <D.27874>:
  D.27831 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27831, inst);
  <D.27875>:
  <D.27870>:
  goto <D.27839>;
  <D.27838>:
  D.27831 = bb->last_ins;
  if (D.27831 != 0B) goto <D.27878>; else goto <D.27879>;
  <D.27878>:
  D.27831 = bb->last_ins;
  D.27831->next = inst;
  D.27831 = bb->last_ins;
  inst->prev = D.27831;
  bb->last_ins = inst;
  goto <D.27880>;
  <D.27879>:
  bb->last_ins = inst;
  D.27831 = bb->last_ins;
  bb->code = D.27831;
  <D.27880>:
  <D.27839>:
  goto <D.25322>;
  <D.25322>:
}


mono_create_jump_table (struct MonoCompile * cfg, struct MonoInst * label, struct MonoBasicBlock * * bbs, int num_blocks)
{
  struct MonoMemPool * D.27882;
  struct MonoJumpInfo * D.27883;
  struct MonoJumpInfo * ji;
  struct MonoJumpInfoBBTable * table;

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


mono_get_array_new_va_icall (int rank)
{
  _Bool D.27886;
  long int D.27887;
  long int D.27888;
  struct GHashTable * jit_icall_name_hash.29;
  _Bool D.27896;
  long int D.27897;
  long int D.27898;
  struct MonoJitICallInfo * D.27901;
  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.27884>; else goto <D.27885>;
        <D.27884>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27885>:
        D.27886 = ret != 0;
        D.27887 = (long int) D.27886;
        D.27888 = __builtin_expect (D.27887, 0);
        if (D.27888 != 0) goto <D.27889>; else goto <D.27890>;
        <D.27889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.27890>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.27891>; else goto <D.27892>;
      <D.27891>:
      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.29 = jit_icall_name_hash;
      monoeg_g_hash_table_insert_replace (jit_icall_name_hash.29, name, name, 0);
      <D.27892>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27894>; else goto <D.27895>;
        <D.27894>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27895>:
        D.27896 = ret != 0;
        D.27897 = (long int) D.27896;
        D.27898 = __builtin_expect (D.27897, 0);
        if (D.27898 != 0) goto <D.27899>; else goto <D.27900>;
        <D.27899>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.27900>:
      }
      D.27901 = info;
      return D.27901;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.27904;
  long unsigned int D.27905;

  D.27905 = __builtin_object_size (__s, 1);
  D.27904 = __builtin___sprintf_chk (__s, 1, D.27905, __fmt, __builtin_va_arg_pack ());
  return D.27904;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.27909;
  long int D.27910;
  long int D.27911;
  struct GHashTable * sighash.30;
  struct GHashTable * sighash.31;
  long int D.27919;
  const void * D.27920;
  _Bool D.27925;
  long int D.27926;
  long int D.27927;
  struct MonoMethodSignature * D.27930;
  int D.27931;
  unsigned int D.27932;
  struct MonoImage * D.27933;
  struct MonoClass * D.27936;
  struct MonoType * D.27937;
  int D.27938;
  struct MonoClass * D.27939;
  struct MonoType * D.27940;
  void * D.27941;
  _Bool D.27944;
  long int D.27945;
  long int D.27946;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27907>; else goto <D.27908>;
    <D.27907>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27908>:
    D.27909 = ret != 0;
    D.27910 = (long int) D.27909;
    D.27911 = __builtin_expect (D.27910, 0);
    if (D.27911 != 0) goto <D.27912>; else goto <D.27913>;
    <D.27912>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.27913>:
  }
  sighash.30 = sighash;
  if (sighash.30 == 0B) goto <D.27915>; else goto <D.27916>;
  <D.27915>:
  sighash.31 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.31;
  goto <D.27918>;
  <D.27916>:
  D.27919 = (long int) arity;
  D.27920 = (const void *) D.27919;
  sighash.30 = sighash;
  res = monoeg_g_hash_table_lookup (sighash.30, D.27920);
  if (res != 0B) goto <D.27921>; else goto <D.27922>;
  <D.27921>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27923>; else goto <D.27924>;
    <D.27923>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27924>:
    D.27925 = ret != 0;
    D.27926 = (long int) D.27925;
    D.27927 = __builtin_expect (D.27926, 0);
    if (D.27927 != 0) goto <D.27928>; else goto <D.27929>;
    <D.27928>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.27929>:
  }
  D.27930 = res;
  return D.27930;
  <D.27922>:
  <D.27918>:
  D.27931 = arity + 1;
  D.27932 = (unsigned int) D.27931;
  D.27933 = mono_defaults.corlib;
  res = mono_metadata_signature_alloc (D.27933, D.27932);
  res->pinvoke = 1;
  if (1 != 0) goto <D.27934>; else goto <D.27935>;
  <D.27934>:
  res->call_convention = 5;
  <D.27935>:
  D.27936 = mono_defaults.int_class;
  D.27937 = &D.27936->byval_arg;
  res->params[0] = D.27937;
  i = 0;
  goto <D.25341>;
  <D.25340>:
  D.27938 = i + 1;
  D.27936 = mono_defaults.int_class;
  D.27937 = &D.27936->byval_arg;
  res->params[D.27938] = D.27937;
  i = i + 1;
  <D.25341>:
  if (i < arity) goto <D.25340>; else goto <D.25342>;
  <D.25342>:
  D.27939 = mono_defaults.object_class;
  D.27940 = &D.27939->byval_arg;
  res->ret = D.27940;
  D.27919 = (long int) arity;
  D.27941 = (void *) D.27919;
  sighash.30 = sighash;
  monoeg_g_hash_table_insert_replace (sighash.30, D.27941, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27942>; else goto <D.27943>;
    <D.27942>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27943>:
    D.27944 = ret != 0;
    D.27945 = (long int) D.27944;
    D.27946 = __builtin_expect (D.27945, 0);
    if (D.27946 != 0) goto <D.27947>; else goto <D.27948>;
    <D.27947>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.27948>:
  }
  D.27930 = res;
  return D.27930;
}


mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.27950;
  struct MonoClass * D.27951;
  gboolean D.27954;

  D.27950 = klass->parent;
  D.27951 = mono_defaults.array_class;
  if (D.27950 == D.27951) goto <D.27952>; else goto <D.27953>;
  <D.27952>:
  D.27954 = 1;
  return D.27954;
  <D.27953>:
  D.27954 = 0;
  return D.27954;
}


mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.27956;
  struct MonoImage * D.27957;
  unsigned char D.27958;
  unsigned char D.27959;
  _Bool D.27960;
  _Bool D.27961;
  _Bool D.27962;
  gboolean D.27965;
  unsigned char D.27968;
  struct MonoImage * D.27970;
  struct MonoImage * D.27971;
  int D.27972;
  struct MonoAssembly * assembly;

  D.27956 = method->klass;
  D.27957 = D.27956->image;
  assembly = D.27957->assembly;
  D.27958 = BIT_FIELD_REF <*method, 8, 256>;
  D.27959 = D.27958 & 124;
  D.27960 = D.27959 != 0;
  D.27961 = D.27959 != 68;
  D.27962 = D.27960 & D.27961;
  if (D.27962 != 0) goto <D.27963>; else goto <D.27964>;
  <D.27963>:
  D.27965 = 0;
  return D.27965;
  <D.27964>:
  D.27968 = assembly->in_gac;
  if (D.27968 != 0) goto <D.27966>; else goto <D.27969>;
  <D.27969>:
  D.27970 = assembly->image;
  D.27971 = mono_defaults.corlib;
  if (D.27970 == D.27971) goto <D.27966>; else goto <D.27967>;
  <D.27966>:
  D.27965 = 0;
  return D.27965;
  <D.27967>:
  D.27972 = mono_is_security_manager_active ();
  if (D.27972 != 0) goto <D.27973>; else goto <D.27974>;
  <D.27973>:
  D.27965 = 0;
  return D.27965;
  <D.27974>:
  D.27965 = mono_assembly_has_skip_verification (assembly);
  return D.27965;
}


mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.27976;
  struct MonoImage * D.27977;
  struct MonoAssembly * D.27978;
  unsigned char D.27979;
  unsigned char D.27980;
  unsigned char D.27981;
  gboolean D.27982;
  int iftmp.32;
  int D.27987;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.27976 = method->klass;
  D.27977 = D.27976->image;
  D.27978 = D.27977->assembly;
  D.27979 = D.27978->corlib_internal;
  dont_verify = (gboolean) D.27979;
  goto <D.25385>;
  <D.25384>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.25385>:
  D.27980 = BIT_FIELD_REF <*method_definition, 8, 264>;
  D.27981 = D.27980 & 16;
  if (D.27981 != 0) goto <D.25384>; else goto <D.25386>;
  <D.25386>:
  if (dont_verify == 0) goto <D.27986>; else goto <D.27984>;
  <D.27986>:
  D.27987 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.27987 != 0) goto <D.27988>; else goto <D.27984>;
  <D.27988>:
  iftmp.32 = 1;
  goto <D.27985>;
  <D.27984>:
  iftmp.32 = 0;
  <D.27985>:
  D.27982 = iftmp.32;
  return D.27982;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  unsigned char D.27990;
  unsigned char D.27991;
  gboolean D.27994;
  int D.27995;
  int iftmp.33;
  int D.28002;
  struct MonoDomain * D.28004;
  int D.28005;
  <unnamed-unsigned:1> D.28006;
  int D.28007;
  unsigned char D.28012;
  unsigned int D.28013;
  <unnamed type> D.28019;
  signed char D.28024;
  unsigned int D.28025;
  char * D.28026;
  gchar * D.28027;
  gchar * D.28036;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.27990 = BIT_FIELD_REF <*method, 8, 264>;
  D.27991 = D.27990 & 64;
  if (D.27991 != 0) goto <D.27992>; else goto <D.27993>;
  <D.27992>:
  D.27994 = 0;
  return D.27994;
  <D.27993>:
  D.27995 = mono_verifier_is_enabled_for_method (method);
  if (D.27995 == 0) goto <D.27996>; else goto <D.27997>;
  <D.27996>:
  D.27994 = 0;
  return D.27994;
  <D.27997>:
  D.28002 = mono_verifier_is_method_full_trust (method);
  if (D.28002 != 0) goto <D.27999>; else goto <D.28003>;
  <D.28003>:
  D.28004 = cfg->domain;
  D.28005 = mini_assembly_can_skip_verification (D.28004, method);
  if (D.28005 != 0) goto <D.27999>; else goto <D.28000>;
  <D.27999>:
  iftmp.33 = 1;
  goto <D.28001>;
  <D.28000>:
  iftmp.33 = 0;
  <D.28001>:
  is_fulltrust = iftmp.33;
  D.28006 = cfg->skip_visibility;
  D.28007 = (int) D.28006;
  res = mono_method_verify_with_current_settings (method, D.28007, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.28008>; else goto <D.28009>;
  <D.28008>:
  if (fail_compile != 0) goto <D.28010>; else goto <D.28011>;
  <D.28010>:
  D.28012 = error->exception_type;
  D.28013 = (unsigned int) D.28012;
  cfg->exception_type = D.28013;
  goto <D.28014>;
  <D.28011>:
  mono_loader_clear_error ();
  <D.28014>:
  if (res != 0B) goto <D.28015>; else goto <D.28016>;
  <D.28015>:
  mono_free_verify_list (res);
  <D.28016>:
  D.27994 = 1;
  return D.27994;
  <D.28009>:
  if (res != 0B) goto <D.28017>; else goto <D.28018>;
  <D.28017>:
  tmp = res;
  goto <D.25374>;
  <D.25373>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.28019 = info->info.status;
    if (D.28019 == 1) goto <D.28020>; else goto <D.28021>;
    <D.28020>:
    if (fail_compile != 0) goto <D.28022>; else goto <D.28023>;
    <D.28022>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.28024 = info->exception_type;
      D.28025 = (unsigned int) D.28024;
      cfg->exception_type = D.28025;
      D.28026 = info->info.message;
      D.28027 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.28026);
      cfg->exception_message = D.28027;
      monoeg_g_free (method_name);
    }
    <D.28023>:
    mono_free_verify_list (res);
    D.27994 = 1;
    return D.27994;
    <D.28021>:
    D.28019 = info->info.status;
    if (D.28019 == 8) goto <D.28030>; else goto <D.28031>;
    <D.28030>:
    if (is_fulltrust == 0) goto <D.28028>; else goto <D.28032>;
    <D.28032>:
    D.28024 = info->exception_type;
    if (D.28024 == 9) goto <D.28028>; else goto <D.28033>;
    <D.28033>:
    D.28024 = info->exception_type;
    if (D.28024 == 10) goto <D.28028>; else goto <D.28029>;
    <D.28028>:
    if (fail_compile != 0) goto <D.28034>; else goto <D.28035>;
    <D.28034>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.28024 = info->exception_type;
      D.28025 = (unsigned int) D.28024;
      cfg->exception_type = D.28025;
      D.28026 = info->info.message;
      D.28036 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.28026);
      cfg->exception_message = D.28036;
      monoeg_g_free (method_name);
    }
    <D.28035>:
    mono_free_verify_list (res);
    D.27994 = 1;
    return D.27994;
    <D.28029>:
    <D.28031>:
  }
  tmp = tmp->next;
  <D.25374>:
  if (tmp != 0B) goto <D.25373>; else goto <D.25375>;
  <D.25375>:
  mono_free_verify_list (res);
  <D.28018>:
  method->verification_success = 1;
  D.27994 = 0;
  return D.27994;
}


mono_icall_get_wrapper (struct MonoJitICallInfo * callinfo)
{
  const void * D.28038;

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


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.28040;
  const void * D.28043;
  const void * D.28044;
  union mono_mutex_t * D.28047;
  _Bool D.28050;
  long int D.28051;
  long int D.28052;
  _Bool D.28059;
  long int D.28060;
  long int D.28061;
  const char * D.28064;
  int check_for_pending_exc.34;
  const void * D.28066;
  struct MonoMethodSignature * D.28067;
  void * D.28071;
  _Bool D.28074;
  long int D.28075;
  long int D.28076;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.28040 = callinfo->wrapper;
  if (D.28040 != 0B) goto <D.28041>; else goto <D.28042>;
  <D.28041>:
  D.28043 = callinfo->wrapper;
  return D.28043;
  <D.28042>:
  D.28044 = callinfo->trampoline;
  if (D.28044 != 0B) goto <D.28045>; else goto <D.28046>;
  <D.28045>:
  D.28043 = callinfo->trampoline;
  return D.28043;
  <D.28046>:
  mono_loader_lock ();
  {
    int ret;

    D.28047 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28047);
    if (ret != 0) goto <D.28048>; else goto <D.28049>;
    <D.28048>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28049>:
    D.28050 = ret != 0;
    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", 1697, "ret == 0");
    <D.28054>:
  }
  D.28044 = callinfo->trampoline;
  if (D.28044 != 0B) goto <D.28055>; else goto <D.28056>;
  <D.28055>:
  {
    int ret;

    D.28047 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28047);
    if (ret != 0) goto <D.28057>; else goto <D.28058>;
    <D.28057>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28058>:
    D.28059 = ret != 0;
    D.28060 = (long int) D.28059;
    D.28061 = __builtin_expect (D.28060, 0);
    if (D.28061 != 0) goto <D.28062>; else goto <D.28063>;
    <D.28062>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.28063>:
  }
  mono_loader_unlock ();
  D.28043 = callinfo->trampoline;
  return D.28043;
  <D.28056>:
  D.28064 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.28064);
  check_for_pending_exc.34 = check_for_pending_exc;
  D.28066 = callinfo->func;
  D.28067 = callinfo->sig;
  wrapper = mono_marshal_get_icall_wrapper (D.28067, name, D.28066, check_for_pending_exc.34);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.28068>; else goto <D.28069>;
  <D.28068>:
  trampoline = mono_compile_method (wrapper);
  goto <D.28070>;
  <D.28069>:
  D.28071 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.28071);
  <D.28070>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.28047 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28047);
    if (ret != 0) goto <D.28072>; else goto <D.28073>;
    <D.28072>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28073>:
    D.28074 = ret != 0;
    D.28075 = (long int) D.28074;
    D.28076 = __builtin_expect (D.28075, 0);
    if (D.28076 != 0) goto <D.28077>; else goto <D.28078>;
    <D.28077>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.28078>:
  }
  mono_loader_unlock ();
  D.28043 = callinfo->trampoline;
  return D.28043;
}


mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.28080;
  struct MonoMethodVar * D.28083;
  struct MonoLiveInterval * D.28084;
  gint32 * D.28087;
  struct MonoMemPool * D.28088;
  unsigned int D.28089;
  long unsigned int D.28090;
  long unsigned int D.28091;
  gint32 * D.28092;
  unsigned int i.35;
  unsigned int D.28094;
  struct MonoInst * * D.28095;
  long unsigned int D.28096;
  struct MonoInst * * D.28097;
  long unsigned int D.28098;
  unsigned char D.28101;
  int D.28102;
  int D.28103;
  short unsigned int D.28105;
  unsigned int D.28107;
  long unsigned int D.28108;
  long unsigned int D.28109;
  struct MonoInst * * D.28110;
  struct MonoType * D.28111;
  int D.28112;
  int D.28115;
  int D.28120;
  int D.28122;
  unsigned char D.28124;
  struct MonoClass * D.28126;
  int ialign.36;
  unsigned int ialign.37;
  struct MonoClass * D.28129;
  unsigned char D.28130;
  unsigned int D.28133;
  unsigned int D.28134;
  struct MonoClass * D.28137;
  unsigned char D.28138;
  unsigned char D.28139;
  unsigned char D.28142;
  unsigned char D.28143;
  unsigned char D.28146;
  unsigned char D.28147;
  int D.28151;
  int D.28152;
  long unsigned int D.28155;
  long unsigned int D.28156;
  struct MonoClass * D.28159;
  long unsigned int D.28160;
  struct StackSlotInfo * D.28161;
  struct MonoClass * D.28162;
  _Bool D.28167;
  long int D.28168;
  long int D.28169;
  long unsigned int D.28172;
  long unsigned int D.28173;
  struct StackSlotInfo * D.28174;
  unsigned char D.28175;
  unsigned char D.28178;
  unsigned int D.28183;
  unsigned int D.28184;
  struct GList * D.28187;
  unsigned int D.28188;
  unsigned int D.28189;
  struct GList * D.28191;
  unsigned int D.28192;
  long unsigned int D.28193;
  long unsigned int D.28194;
  gint32 * D.28195;
  int D.28196;
  long int D.28197;
  void * D.28198;
  struct GSList * D.28199;
  struct GSList * D.28200;
  int D.28201;
  void * D.28206;
  long int D.28207;
  struct GSList * D.28208;
  struct GList * D.28209;
  int count.38;
  int count.39;
  int D.28212;
  int D.28219;
  unsigned int align.40;
  unsigned int align.41;
  guint32 iftmp.42;
  struct MonoClass * D.28225;
  int D.28226;
  unsigned int D.28227;
  struct MonoClass * D.28230;
  int D.28231;
  unsigned int size.43;
  unsigned int D.28234;
  unsigned int D.28235;
  unsigned int D.28236;
  unsigned int D.28237;
  unsigned int offset.44;
  unsigned int D.28241;
  unsigned int D.28242;
  unsigned int D.28243;
  unsigned int D.28245;
  unsigned int D.28246;
  long unsigned int D.28247;
  gint32 * D.28248;
  struct StackSlotInfo * D.28249;
  struct GList * D.28250;
  struct GList * D.28253;
  int D.28256;
  int D.28257;
  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.28080 = cfg->num_varinfo;
      if (D.28080 != 0) goto <D.28081>; else goto <D.28082>;
      <D.28081>:
      D.28083 = cfg->vars;
      D.28084 = D.28083->interval;
      if (D.28084 != 0B) goto <D.28085>; else goto <D.28086>;
      <D.28085>:
      D.28087 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.28087;
      <D.28086>:
      <D.28082>:
      D.28088 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.28088, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.28080 = cfg->num_varinfo;
      D.28089 = D.28080 * 4;
      D.28088 = cfg->mempool;
      offsets = mono_mempool_alloc (D.28088, D.28089);
      i = 0;
      goto <D.25520>;
      <D.25519>:
      D.28090 = (long unsigned int) i;
      D.28091 = D.28090 * 4;
      D.28092 = offsets + D.28091;
      *D.28092 = -1;
      i = i + 1;
      <D.25520>:
      i.35 = (unsigned int) i;
      D.28080 = cfg->num_varinfo;
      if (i.35 < D.28080) goto <D.25519>; else goto <D.25521>;
      <D.25521>:
      D.28094 = cfg->locals_start;
      i = (int) D.28094;
      goto <D.25524>;
      <D.25523>:
      D.28095 = cfg->varinfo;
      D.28090 = (long unsigned int) i;
      D.28096 = D.28090 * 8;
      D.28097 = D.28095 + D.28096;
      inst = *D.28097;
      D.28083 = cfg->vars;
      D.28090 = (long unsigned int) i;
      D.28098 = D.28090 * 80;
      vmv = D.28083 + D.28098;
      D.28101 = inst->flags;
      D.28102 = (int) D.28101;
      D.28103 = D.28102 & 2;
      if (D.28103 != 0) goto <D.28099>; else goto <D.28104>;
      <D.28104>:
      D.28105 = inst->opcode;
      if (D.28105 == 366) goto <D.28099>; else goto <D.28106>;
      <D.28106>:
      D.28105 = inst->opcode;
      if (D.28105 == 367) goto <D.28099>; else goto <D.28100>;
      <D.28099>:
      // predicted unlikely by continue predictor.
      goto <D.25522>;
      <D.28100>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25522>:
      i = i + 1;
      <D.25524>:
      i.35 = (unsigned int) i;
      D.28080 = cfg->num_varinfo;
      if (i.35 < D.28080) goto <D.25523>; else goto <D.25525>;
      <D.25525>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 8;
      l = vars;
      goto <D.25552>;
      <D.25551>:
      vmv = l->data;
      D.28095 = cfg->varinfo;
      D.28107 = vmv->idx;
      D.28108 = (long unsigned int) D.28107;
      D.28109 = D.28108 * 8;
      D.28110 = D.28095 + D.28109;
      inst = *D.28110;
      D.28111 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.28111);
      D.28112 = cfg->gsharedvt;
      if (D.28112 != 0) goto <D.28113>; else goto <D.28114>;
      <D.28113>:
      D.28115 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.28115 != 0) goto <D.28116>; else goto <D.28117>;
      <D.28116>:
      // predicted unlikely by continue predictor.
      goto <D.25526>;
      <D.28117>:
      <D.28114>:
      D.28120 = inst->backend.is_pinvoke;
      if (D.28120 != 0) goto <D.28121>; else goto <D.28118>;
      <D.28121>:
      D.28122 = mono_type_is_struct (t);
      if (D.28122 != 0) goto <D.28123>; else goto <D.28118>;
      <D.28123>:
      D.28124 = t->type;
      if (D.28124 != 22) goto <D.28125>; else goto <D.28118>;
      <D.28125>:
      D.28126 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.28126, &align);
      goto <D.28119>;
      <D.28118>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.36 = ialign;
            ialign.37 = (unsigned int) ialign.36;
            align = ialign.37;
            D.28129 = mono_class_from_mono_type (t);
            D.28130 = D.28129->exception_type;
            if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
            <D.28131>:
            mono_cfg_set_exception (cfg, 7);
            <D.28132>:
            D.28133 = cfg->opt;
            D.28134 = D.28133 & 67108864;
            if (D.28134 != 0) goto <D.28135>; else goto <D.28136>;
            <D.28135>:
            D.28137 = mono_class_from_mono_type (t);
            D.28138 = BIT_FIELD_REF <*D.28137, 8, 288>;
            D.28139 = D.28138 & 2;
            if (D.28139 != 0) goto <D.28140>; else goto <D.28141>;
            <D.28140>:
            align = 16;
            <D.28141>:
            <D.28136>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.28119>:
      reuse_slot = 1;
      D.28142 = BIT_FIELD_REF <*cfg, 8, 5616>;
      D.28143 = D.28142 & 1;
      if (D.28143 != 0) goto <D.28144>; else goto <D.28145>;
      <D.28144>:
      reuse_slot = 0;
      <D.28145>:
      D.28146 = BIT_FIELD_REF <*t, 8, 88>;
      D.28147 = D.28146 & 64;
      if (D.28147 != 0) goto <D.28148>; else goto <D.28149>;
      <D.28148>:
      slot_info = scalar_stack_slots + 768;
      goto <D.28150>;
      <D.28149>:
      D.28124 = t->type;
      D.28151 = (int) D.28124;
      switch (D.28151) <default: <D.25545>, case 10: <D.25537>, case 14: <D.25542>, case 15: <D.25534>, case 17: <D.25530>, case 18: <D.25538>, case 19: <D.25543>, case 20: <D.25540>, case 21: <D.25528>, case 24: <D.25535>, case 25: <D.25536>, case 28: <D.25539>, case 29: <D.25541>, case 30: <D.25544>>
      <D.25528>:
      D.28152 = mono_type_generic_inst_is_valuetype (t);
      if (D.28152 == 0) goto <D.28153>; else goto <D.28154>;
      <D.28153>:
      D.28124 = t->type;
      D.28155 = (long unsigned int) D.28124;
      D.28156 = D.28155 * 32;
      slot_info = scalar_stack_slots + D.28156;
      goto <D.25529>;
      <D.28154>:
      <D.25530>:
      if (vtype_stack_slots == 0B) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      D.28088 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.28088, 8192);
      <D.28158>:
      i = 0;
      goto <D.25533>;
      <D.25532>:
      D.28159 = t->data.klass;
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      D.28161 = vtype_stack_slots + D.28160;
      D.28162 = D.28161->vtype;
      if (D.28159 == D.28162) goto <D.25531>; else goto <D.28163>;
      <D.28163>:
      i = i + 1;
      <D.25533>:
      if (i < nvtypes) goto <D.25532>; else goto <D.25531>;
      <D.25531>:
      if (i < nvtypes) goto <D.28164>; else goto <D.28165>;
      <D.28164>:
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      slot_info = vtype_stack_slots + D.28160;
      goto <D.28166>;
      <D.28165>:
      D.28167 = nvtypes > 255;
      D.28168 = (long int) D.28167;
      D.28169 = __builtin_expect (D.28168, 0);
      if (D.28169 != 0) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.28171>:
      D.28172 = (long unsigned int) nvtypes;
      D.28173 = D.28172 * 32;
      D.28174 = vtype_stack_slots + D.28173;
      D.28159 = t->data.klass;
      D.28174->vtype = D.28159;
      D.28172 = (long unsigned int) nvtypes;
      D.28173 = D.28172 * 32;
      slot_info = vtype_stack_slots + D.28173;
      nvtypes = nvtypes + 1;
      <D.28166>:
      D.28142 = BIT_FIELD_REF <*cfg, 8, 5616>;
      D.28175 = D.28142 & 2;
      if (D.28175 != 0) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      reuse_slot = 0;
      <D.28177>:
      goto <D.25529>;
      <D.25534>:
      <D.25535>:
      <D.25536>:
      <D.25537>:
      D.28142 = BIT_FIELD_REF <*cfg, 8, 5616>;
      D.28178 = D.28142 & 4;
      if (D.28178 != 0) goto <D.28179>; else goto <D.28180>;
      <D.28179>:
      slot_info = scalar_stack_slots + 768;
      goto <D.25529>;
      <D.28180>:
      <D.25538>:
      <D.25539>:
      <D.25540>:
      <D.25541>:
      <D.25542>:
      slot_info = scalar_stack_slots + 576;
      D.28142 = BIT_FIELD_REF <*cfg, 8, 5616>;
      D.28175 = D.28142 & 2;
      if (D.28175 != 0) goto <D.28181>; else goto <D.28182>;
      <D.28181>:
      reuse_slot = 0;
      <D.28182>:
      goto <D.25529>;
      <D.25543>:
      <D.25544>:
      D.28124 = t->type;
      D.28155 = (long unsigned int) D.28124;
      D.28156 = D.28155 * 32;
      slot_info = scalar_stack_slots + D.28156;
      goto <D.25529>;
      <D.25545>:
      D.28124 = t->type;
      D.28155 = (long unsigned int) D.28124;
      D.28156 = D.28155 * 32;
      slot_info = scalar_stack_slots + D.28156;
      goto <D.25529>;
      <D.25529>:
      <D.28150>:
      slot = 16777215;
      D.28183 = cfg->comp_done;
      D.28184 = D.28183 & 16;
      if (D.28184 != 0) goto <D.28185>; else goto <D.28186>;
      <D.28185>:
      goto <D.25549>;
      <D.25548>:
      {
        struct MonoMethodVar * amv;

        D.28187 = slot_info->active;
        amv = D.28187->data;
        D.28188 = amv->range.last_use.abs_pos;
        D.28189 = vmv->range.first_use.abs_pos;
        if (D.28188 > D.28189) goto <D.25547>; else goto <D.28190>;
        <D.28190>:
        D.28187 = slot_info->active;
        D.28187 = slot_info->active;
        D.28191 = monoeg_g_list_delete_link (D.28187, D.28187);
        slot_info->active = D.28191;
        D.28192 = amv->idx;
        D.28193 = (long unsigned int) D.28192;
        D.28194 = D.28193 * 4;
        D.28195 = offsets + D.28194;
        D.28196 = *D.28195;
        D.28197 = (long int) D.28196;
        D.28198 = (void *) D.28197;
        D.28199 = slot_info->slots;
        D.28088 = cfg->mempool;
        D.28200 = g_slist_prepend_mempool (D.28088, D.28199, D.28198);
        slot_info->slots = D.28200;
      }
      <D.25549>:
      D.28187 = slot_info->active;
      if (D.28187 != 0B) goto <D.25548>; else goto <D.25547>;
      <D.25547>:
      D.28101 = inst->flags;
      D.28102 = (int) D.28101;
      D.28201 = D.28102 & 20;
      if (D.28201 == 0) goto <D.28202>; else goto <D.28203>;
      <D.28202>:
      D.28199 = slot_info->slots;
      if (D.28199 != 0B) goto <D.28204>; else goto <D.28205>;
      <D.28204>:
      D.28199 = slot_info->slots;
      D.28206 = D.28199->data;
      D.28207 = (long int) D.28206;
      slot = (int) D.28207;
      D.28199 = slot_info->slots;
      D.28208 = D.28199->next;
      slot_info->slots = D.28208;
      <D.28205>:
      D.28187 = slot_info->active;
      D.28209 = mono_varlist_insert_sorted (cfg, D.28187, vmv, 1);
      slot_info->active = D.28209;
      <D.28203>:
      <D.28186>:
      {
        static int count = 0;

        count.38 = count;
        count.39 = count.38 + 1;
        count = count.39;
      }
      D.28101 = inst->flags;
      D.28102 = (int) D.28101;
      D.28212 = D.28102 & 32;
      if (D.28212 != 0) goto <D.28213>; else goto <D.28214>;
      <D.28213>:
      size = 72;
      align = 8;
      reuse_slot = 0;
      <D.28214>:
      if (reuse_slot == 0) goto <D.28215>; else goto <D.28216>;
      <D.28215>:
      slot = 16777215;
      <D.28216>:
      if (slot == 16777215) goto <D.28217>; else goto <D.28218>;
      <D.28217>:
      D.28219 = mono_type_is_struct (t);
      if (D.28219 != 0) goto <D.28220>; else goto <D.28221>;
      <D.28220>:
      align.40 = align;
      align.41 = MAX_EXPR <align.40, 8>;
      align = align.41;
      D.28225 = mono_class_from_mono_type (t);
      D.28226 = mono_class_min_align (D.28225);
      D.28227 = (unsigned int) D.28226;
      align.40 = align;
      if (D.28227 >= align.40) goto <D.28228>; else goto <D.28229>;
      <D.28228>:
      D.28230 = mono_class_from_mono_type (t);
      D.28231 = mono_class_min_align (D.28230);
      iftmp.42 = (guint32) D.28231;
      goto <D.28232>;
      <D.28229>:
      iftmp.42 = align;
      <D.28232>:
      align = iftmp.42;
      align.40 = align;
      size.43 = (unsigned int) size;
      D.28234 = align.40 + size.43;
      D.28235 = D.28234 + 4294967295;
      align.40 = align;
      D.28236 = -align.40;
      D.28237 = D.28235 & D.28236;
      size = (int) D.28237;
      <D.28221>:
      if (backward != 0) goto <D.28238>; else goto <D.28239>;
      <D.28238>:
      offset = offset + size;
      align.40 = align;
      offset.44 = (unsigned int) offset;
      D.28241 = align.40 + offset.44;
      D.28242 = D.28241 + 4294967295;
      offset = (int) D.28242;
      align.40 = align;
      D.28236 = -align.40;
      offset.44 = (unsigned int) offset;
      D.28243 = D.28236 & offset.44;
      offset = (int) D.28243;
      slot = offset;
      goto <D.28244>;
      <D.28239>:
      align.40 = align;
      offset.44 = (unsigned int) offset;
      D.28241 = align.40 + offset.44;
      D.28242 = D.28241 + 4294967295;
      offset = (int) D.28242;
      align.40 = align;
      D.28236 = -align.40;
      offset.44 = (unsigned int) offset;
      D.28243 = D.28236 & offset.44;
      offset = (int) D.28243;
      slot = offset;
      offset = offset + size;
      <D.28244>:
      D.28245 = *stack_align;
      align.40 = align;
      D.28246 = MAX_EXPR <D.28245, align.40>;
      *stack_align = D.28246;
      <D.28218>:
      D.28107 = vmv->idx;
      D.28108 = (long unsigned int) D.28107;
      D.28247 = D.28108 * 4;
      D.28248 = offsets + D.28247;
      *D.28248 = slot;
      <D.25526>:
      l = l->next;
      <D.25552>:
      if (l != 0B) goto <D.25551>; else goto <D.25553>;
      <D.25553>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25555>;
      <D.25554>:
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      D.28249 = scalar_stack_slots + D.28160;
      D.28250 = D.28249->active;
      if (D.28250 != 0B) goto <D.28251>; else goto <D.28252>;
      <D.28251>:
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      D.28249 = scalar_stack_slots + D.28160;
      D.28250 = D.28249->active;
      monoeg_g_list_free (D.28250);
      <D.28252>:
      i = i + 1;
      <D.25555>:
      if (i <= 68) goto <D.25554>; else goto <D.25556>;
      <D.25556>:
      i = 0;
      goto <D.25558>;
      <D.25557>:
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      D.28161 = vtype_stack_slots + D.28160;
      D.28253 = D.28161->active;
      if (D.28253 != 0B) goto <D.28254>; else goto <D.28255>;
      <D.28254>:
      D.28090 = (long unsigned int) i;
      D.28160 = D.28090 * 32;
      D.28161 = vtype_stack_slots + D.28160;
      D.28253 = D.28161->active;
      monoeg_g_list_free (D.28253);
      <D.28255>:
      i = i + 1;
      <D.25558>:
      if (i < nvtypes) goto <D.25557>; else goto <D.25559>;
      <D.25559>:
      D.28256 = cfg->stat_locals_stack_size;
      D.28257 = D.28256 + offset;
      cfg->stat_locals_stack_size = D.28257;
      offset.44 = (unsigned int) offset;
      *stack_size = offset.44;
      D.28087 = offsets;
      return D.28087;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.28260;
  unsigned int D.28261;
  unsigned int D.28262;
  long unsigned int D.28263;
  long unsigned int D.28264;
  gint32 * D.28265;
  unsigned int i.45;
  unsigned int D.28267;
  struct MonoInst * * D.28268;
  long unsigned int D.28269;
  struct MonoInst * * D.28270;
  struct MonoMethodVar * D.28271;
  long unsigned int D.28272;
  unsigned char D.28275;
  int D.28276;
  int D.28277;
  short unsigned int D.28279;
  struct GList * D.28281;
  unsigned int D.28282;
  long unsigned int D.28283;
  long unsigned int D.28284;
  struct MonoInst * * D.28285;
  struct MonoType * D.28286;
  int D.28287;
  int D.28290;
  int D.28295;
  int D.28297;
  unsigned char D.28299;
  struct MonoClass * D.28301;
  int ialign.46;
  unsigned int ialign.47;
  unsigned int D.28304;
  unsigned int D.28305;
  struct MonoClass * D.28308;
  unsigned char D.28309;
  unsigned char D.28310;
  unsigned char D.28313;
  unsigned char D.28314;
  int D.28317;
  int D.28318;
  long unsigned int D.28321;
  long unsigned int D.28322;
  struct MonoClass * D.28325;
  long unsigned int D.28326;
  struct StackSlotInfo * D.28327;
  struct MonoClass * D.28328;
  _Bool D.28333;
  long int D.28334;
  long int D.28335;
  long unsigned int D.28338;
  long unsigned int D.28339;
  struct StackSlotInfo * D.28340;
  unsigned char D.28341;
  unsigned char D.28344;
  unsigned int D.28349;
  unsigned int D.28350;
  struct MonoLiveInterval * D.28353;
  struct MonoLiveRange2 * D.28354;
  int D.28357;
  unsigned char D.28361;
  struct MonoLiveInterval * D.28365;
  struct MonoLiveRange2 * D.28366;
  int D.28367;
  struct GList * D.28370;
  struct GList * D.28371;
  unsigned int D.28372;
  long unsigned int D.28373;
  long unsigned int D.28374;
  gint32 * D.28375;
  int D.28376;
  long int D.28377;
  void * D.28378;
  struct GSList * D.28379;
  struct GSList * D.28380;
  int D.28381;
  struct GList * D.28384;
  struct GList * D.28385;
  struct GList * D.28386;
  struct MonoLiveInterval * D.28387;
  struct MonoLiveRange2 * D.28388;
  int D.28389;
  struct GList * D.28392;
  int D.28393;
  struct GList * D.28396;
  struct GList * D.28397;
  void * D.28402;
  long int D.28403;
  struct GSList * D.28404;
  struct GList * D.28405;
  int D.28406;
  int D.28413;
  unsigned int align.48;
  unsigned int align.49;
  guint32 iftmp.50;
  struct MonoClass * D.28419;
  int D.28420;
  unsigned int D.28421;
  struct MonoClass * D.28424;
  int D.28425;
  unsigned int offset.51;
  unsigned int D.28430;
  unsigned int D.28431;
  unsigned int D.28432;
  unsigned int D.28433;
  unsigned int D.28435;
  long unsigned int D.28438;
  gint32 * D.28439;
  struct StackSlotInfo * D.28440;
  struct GList * D.28441;
  struct GList * D.28444;
  int D.28447;
  int D.28448;
  gint32 * D.28449;
  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.28260 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.28260, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.28261 = cfg->num_varinfo;
      D.28262 = D.28261 * 4;
      D.28260 = cfg->mempool;
      offsets = mono_mempool_alloc (D.28260, D.28262);
      i = 0;
      goto <D.25447>;
      <D.25446>:
      D.28263 = (long unsigned int) i;
      D.28264 = D.28263 * 4;
      D.28265 = offsets + D.28264;
      *D.28265 = -1;
      i = i + 1;
      <D.25447>:
      i.45 = (unsigned int) i;
      D.28261 = cfg->num_varinfo;
      if (i.45 < D.28261) goto <D.25446>; else goto <D.25448>;
      <D.25448>:
      D.28267 = cfg->locals_start;
      i = (int) D.28267;
      goto <D.25451>;
      <D.25450>:
      D.28268 = cfg->varinfo;
      D.28263 = (long unsigned int) i;
      D.28269 = D.28263 * 8;
      D.28270 = D.28268 + D.28269;
      inst = *D.28270;
      D.28271 = cfg->vars;
      D.28263 = (long unsigned int) i;
      D.28272 = D.28263 * 80;
      vmv = D.28271 + D.28272;
      D.28275 = inst->flags;
      D.28276 = (int) D.28275;
      D.28277 = D.28276 & 2;
      if (D.28277 != 0) goto <D.28273>; else goto <D.28278>;
      <D.28278>:
      D.28279 = inst->opcode;
      if (D.28279 == 366) goto <D.28273>; else goto <D.28280>;
      <D.28280>:
      D.28279 = inst->opcode;
      if (D.28279 == 367) goto <D.28273>; else goto <D.28274>;
      <D.28273>:
      // predicted unlikely by continue predictor.
      goto <D.25449>;
      <D.28274>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25449>:
      i = i + 1;
      <D.25451>:
      i.45 = (unsigned int) i;
      D.28261 = cfg->num_varinfo;
      if (i.45 < D.28261) goto <D.25450>; else goto <D.25452>;
      <D.25452>:
      D.28281 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.28281, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.25489>;
      <D.25488>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.28268 = cfg->varinfo;
        D.28282 = vmv->idx;
        D.28283 = (long unsigned int) D.28282;
        D.28284 = D.28283 * 8;
        D.28285 = D.28268 + D.28284;
        inst = *D.28285;
        D.28286 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.28286);
        D.28287 = cfg->gsharedvt;
        if (D.28287 != 0) goto <D.28288>; else goto <D.28289>;
        <D.28288>:
        D.28290 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.28290 != 0) goto <D.28291>; else goto <D.28292>;
        <D.28291>:
        // predicted unlikely by continue predictor.
        goto <D.25454>;
        <D.28292>:
        <D.28289>:
        D.28295 = inst->backend.is_pinvoke;
        if (D.28295 != 0) goto <D.28296>; else goto <D.28293>;
        <D.28296>:
        D.28297 = mono_type_is_struct (t);
        if (D.28297 != 0) goto <D.28298>; else goto <D.28293>;
        <D.28298>:
        D.28299 = t->type;
        if (D.28299 != 22) goto <D.28300>; else goto <D.28293>;
        <D.28300>:
        D.28301 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.28301, &align);
        goto <D.28294>;
        <D.28293>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.46 = ialign;
              ialign.47 = (unsigned int) ialign.46;
              align = ialign.47;
              D.28304 = cfg->opt;
              D.28305 = D.28304 & 67108864;
              if (D.28305 != 0) goto <D.28306>; else goto <D.28307>;
              <D.28306>:
              D.28308 = mono_class_from_mono_type (t);
              D.28309 = BIT_FIELD_REF <*D.28308, 8, 288>;
              D.28310 = D.28309 & 2;
              if (D.28310 != 0) goto <D.28311>; else goto <D.28312>;
              <D.28311>:
              align = 16;
              <D.28312>:
              <D.28307>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.28294>:
        reuse_slot = 1;
        D.28313 = BIT_FIELD_REF <*cfg, 8, 5616>;
        D.28314 = D.28313 & 1;
        if (D.28314 != 0) goto <D.28315>; else goto <D.28316>;
        <D.28315>:
        reuse_slot = 0;
        <D.28316>:
        D.28299 = t->type;
        D.28317 = (int) D.28299;
        switch (D.28317) <default: <D.25471>, case 10: <D.25465>, case 14: <D.25470>, case 15: <D.25462>, case 17: <D.25458>, case 18: <D.25466>, case 20: <D.25468>, case 21: <D.25456>, case 24: <D.25463>, case 25: <D.25464>, case 28: <D.25467>, case 29: <D.25469>>
        <D.25456>:
        D.28318 = mono_type_generic_inst_is_valuetype (t);
        if (D.28318 == 0) goto <D.28319>; else goto <D.28320>;
        <D.28319>:
        D.28299 = t->type;
        D.28321 = (long unsigned int) D.28299;
        D.28322 = D.28321 * 32;
        slot_info = scalar_stack_slots + D.28322;
        goto <D.25457>;
        <D.28320>:
        <D.25458>:
        if (vtype_stack_slots == 0B) goto <D.28323>; else goto <D.28324>;
        <D.28323>:
        D.28260 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.28260, 8192);
        <D.28324>:
        i = 0;
        goto <D.25461>;
        <D.25460>:
        D.28325 = t->data.klass;
        D.28263 = (long unsigned int) i;
        D.28326 = D.28263 * 32;
        D.28327 = vtype_stack_slots + D.28326;
        D.28328 = D.28327->vtype;
        if (D.28325 == D.28328) goto <D.25459>; else goto <D.28329>;
        <D.28329>:
        i = i + 1;
        <D.25461>:
        if (i < nvtypes) goto <D.25460>; else goto <D.25459>;
        <D.25459>:
        if (i < nvtypes) goto <D.28330>; else goto <D.28331>;
        <D.28330>:
        D.28263 = (long unsigned int) i;
        D.28326 = D.28263 * 32;
        slot_info = vtype_stack_slots + D.28326;
        goto <D.28332>;
        <D.28331>:
        D.28333 = nvtypes > 255;
        D.28334 = (long int) D.28333;
        D.28335 = __builtin_expect (D.28334, 0);
        if (D.28335 != 0) goto <D.28336>; else goto <D.28337>;
        <D.28336>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.28337>:
        D.28338 = (long unsigned int) nvtypes;
        D.28339 = D.28338 * 32;
        D.28340 = vtype_stack_slots + D.28339;
        D.28325 = t->data.klass;
        D.28340->vtype = D.28325;
        D.28338 = (long unsigned int) nvtypes;
        D.28339 = D.28338 * 32;
        slot_info = vtype_stack_slots + D.28339;
        nvtypes = nvtypes + 1;
        <D.28332>:
        D.28313 = BIT_FIELD_REF <*cfg, 8, 5616>;
        D.28341 = D.28313 & 2;
        if (D.28341 != 0) goto <D.28342>; else goto <D.28343>;
        <D.28342>:
        reuse_slot = 0;
        <D.28343>:
        goto <D.25457>;
        <D.25462>:
        <D.25463>:
        <D.25464>:
        <D.25465>:
        D.28313 = BIT_FIELD_REF <*cfg, 8, 5616>;
        D.28344 = D.28313 & 4;
        if (D.28344 != 0) goto <D.28345>; else goto <D.28346>;
        <D.28345>:
        slot_info = scalar_stack_slots + 768;
        goto <D.25457>;
        <D.28346>:
        <D.25466>:
        <D.25467>:
        <D.25468>:
        <D.25469>:
        <D.25470>:
        slot_info = scalar_stack_slots + 576;
        D.28313 = BIT_FIELD_REF <*cfg, 8, 5616>;
        D.28341 = D.28313 & 2;
        if (D.28341 != 0) goto <D.28347>; else goto <D.28348>;
        <D.28347>:
        reuse_slot = 0;
        <D.28348>:
        goto <D.25457>;
        <D.25471>:
        D.28299 = t->type;
        D.28321 = (long unsigned int) D.28299;
        D.28322 = D.28321 * 32;
        slot_info = scalar_stack_slots + D.28322;
        <D.25457>:
        slot = 16777215;
        D.28349 = cfg->comp_done;
        D.28350 = D.28349 & 16;
        if (D.28350 != 0) goto <D.28351>; else goto <D.28352>;
        <D.28351>:
        {
          int pos;
          gboolean changed;

          D.28353 = current->interval;
          D.28354 = D.28353->range;
          if (D.28354 == 0B) goto <D.28355>; else goto <D.28356>;
          <D.28355>:
          D.28275 = inst->flags;
          D.28276 = (int) D.28275;
          D.28357 = D.28276 & 20;
          if (D.28357 != 0) goto <D.28358>; else goto <D.28359>;
          <D.28358>:
          pos = -1;
          goto <D.28360>;
          <D.28359>:
          D.28275 = inst->flags;
          D.28361 = D.28275 | 2;
          inst->flags = D.28361;
          // predicted unlikely by continue predictor.
          goto <D.25454>;
          <D.28360>:
          goto <D.28362>;
          <D.28356>:
          D.28353 = current->interval;
          D.28354 = D.28353->range;
          pos = D.28354->from;
          <D.28362>:
          D.28353 = current->interval;
          D.28354 = D.28353->range;
          if (D.28354 != 0B) goto <D.28363>; else goto <D.28364>;
          <D.28363>:
          <D.28364>:
          changed = 1;
          goto <D.25479>;
          <D.25478>:
          changed = 0;
          l = slot_info->active;
          goto <D.25477>;
          <D.25476>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28365 = v->interval;
            D.28366 = D.28365->last_range;
            D.28367 = D.28366->to;
            if (D.28367 < pos) goto <D.28368>; else goto <D.28369>;
            <D.28368>:
            D.28370 = slot_info->active;
            D.28371 = monoeg_g_list_delete_link (D.28370, l);
            slot_info->active = D.28371;
            D.28372 = v->idx;
            D.28373 = (long unsigned int) D.28372;
            D.28374 = D.28373 * 4;
            D.28375 = offsets + D.28374;
            D.28376 = *D.28375;
            D.28377 = (long int) D.28376;
            D.28378 = (void *) D.28377;
            D.28379 = slot_info->slots;
            D.28260 = cfg->mempool;
            D.28380 = g_slist_prepend_mempool (D.28260, D.28379, D.28378);
            slot_info->slots = D.28380;
            changed = 1;
            goto <D.25475>;
            <D.28369>:
            D.28365 = v->interval;
            D.28381 = mono_linterval_covers (D.28365, pos);
            if (D.28381 == 0) goto <D.28382>; else goto <D.28383>;
            <D.28382>:
            D.28384 = slot_info->inactive;
            D.28385 = monoeg_g_list_append (D.28384, v);
            slot_info->inactive = D.28385;
            D.28370 = slot_info->active;
            D.28386 = monoeg_g_list_delete_link (D.28370, l);
            slot_info->active = D.28386;
            changed = 1;
            goto <D.25475>;
            <D.28383>:
          }
          l = l->next;
          <D.25477>:
          if (l != 0B) goto <D.25476>; else goto <D.25475>;
          <D.25475>:
          <D.25479>:
          if (changed != 0) goto <D.25478>; else goto <D.25480>;
          <D.25480>:
          changed = 1;
          goto <D.25486>;
          <D.25485>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.25484>;
          <D.25483>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28387 = v->interval;
            D.28388 = D.28387->last_range;
            D.28389 = D.28388->to;
            if (D.28389 < pos) goto <D.28390>; else goto <D.28391>;
            <D.28390>:
            D.28384 = slot_info->inactive;
            D.28392 = monoeg_g_list_delete_link (D.28384, l);
            slot_info->inactive = D.28392;
            changed = 1;
            goto <D.25482>;
            <D.28391>:
            D.28387 = v->interval;
            D.28393 = mono_linterval_covers (D.28387, pos);
            if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
            <D.28394>:
            D.28370 = slot_info->active;
            D.28396 = monoeg_g_list_append (D.28370, v);
            slot_info->active = D.28396;
            D.28384 = slot_info->inactive;
            D.28397 = monoeg_g_list_delete_link (D.28384, l);
            slot_info->inactive = D.28397;
            changed = 1;
            goto <D.25482>;
            <D.28395>:
          }
          l = l->next;
          <D.25484>:
          if (l != 0B) goto <D.25483>; else goto <D.25482>;
          <D.25482>:
          <D.25486>:
          if (changed != 0) goto <D.25485>; else goto <D.25487>;
          <D.25487>:
          D.28275 = inst->flags;
          D.28276 = (int) D.28275;
          D.28357 = D.28276 & 20;
          if (D.28357 == 0) goto <D.28398>; else goto <D.28399>;
          <D.28398>:
          D.28379 = slot_info->slots;
          if (D.28379 != 0B) goto <D.28400>; else goto <D.28401>;
          <D.28400>:
          D.28379 = slot_info->slots;
          D.28402 = D.28379->data;
          D.28403 = (long int) D.28402;
          slot = (int) D.28403;
          D.28379 = slot_info->slots;
          D.28404 = D.28379->next;
          slot_info->slots = D.28404;
          <D.28401>:
          D.28370 = slot_info->active;
          D.28405 = mono_varlist_insert_sorted (cfg, D.28370, vmv, 1);
          slot_info->active = D.28405;
          <D.28399>:
        }
        <D.28352>:
        D.28275 = inst->flags;
        D.28276 = (int) D.28275;
        D.28406 = D.28276 & 32;
        if (D.28406 != 0) goto <D.28407>; else goto <D.28408>;
        <D.28407>:
        size = 72;
        align = 8;
        reuse_slot = 0;
        <D.28408>:
        if (reuse_slot == 0) goto <D.28409>; else goto <D.28410>;
        <D.28409>:
        slot = 16777215;
        <D.28410>:
        if (slot == 16777215) goto <D.28411>; else goto <D.28412>;
        <D.28411>:
        D.28413 = mono_type_is_struct (t);
        if (D.28413 != 0) goto <D.28414>; else goto <D.28415>;
        <D.28414>:
        align.48 = align;
        align.49 = MAX_EXPR <align.48, 8>;
        align = align.49;
        D.28419 = mono_class_from_mono_type (t);
        D.28420 = mono_class_min_align (D.28419);
        D.28421 = (unsigned int) D.28420;
        align.48 = align;
        if (D.28421 >= align.48) goto <D.28422>; else goto <D.28423>;
        <D.28422>:
        D.28424 = mono_class_from_mono_type (t);
        D.28425 = mono_class_min_align (D.28424);
        iftmp.50 = (guint32) D.28425;
        goto <D.28426>;
        <D.28423>:
        iftmp.50 = align;
        <D.28426>:
        align = iftmp.50;
        <D.28415>:
        if (backward != 0) goto <D.28427>; else goto <D.28428>;
        <D.28427>:
        offset = offset + size;
        align.48 = align;
        offset.51 = (unsigned int) offset;
        D.28430 = align.48 + offset.51;
        D.28431 = D.28430 + 4294967295;
        offset = (int) D.28431;
        align.48 = align;
        D.28432 = -align.48;
        offset.51 = (unsigned int) offset;
        D.28433 = D.28432 & offset.51;
        offset = (int) D.28433;
        slot = offset;
        goto <D.28434>;
        <D.28428>:
        align.48 = align;
        offset.51 = (unsigned int) offset;
        D.28430 = align.48 + offset.51;
        D.28431 = D.28430 + 4294967295;
        offset = (int) D.28431;
        align.48 = align;
        D.28432 = -align.48;
        offset.51 = (unsigned int) offset;
        D.28433 = D.28432 & offset.51;
        offset = (int) D.28433;
        slot = offset;
        offset = offset + size;
        <D.28434>:
        D.28435 = *stack_align;
        if (D.28435 == 0) goto <D.28436>; else goto <D.28437>;
        <D.28436>:
        align.48 = align;
        *stack_align = align.48;
        <D.28437>:
        <D.28412>:
        D.28282 = vmv->idx;
        D.28283 = (long unsigned int) D.28282;
        D.28438 = D.28283 * 4;
        D.28439 = offsets + D.28438;
        *D.28439 = slot;
      }
      <D.25454>:
      unhandled = unhandled->next;
      <D.25489>:
      if (unhandled != 0B) goto <D.25488>; else goto <D.25490>;
      <D.25490>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25492>;
      <D.25491>:
      D.28263 = (long unsigned int) i;
      D.28326 = D.28263 * 32;
      D.28440 = scalar_stack_slots + D.28326;
      D.28441 = D.28440->active;
      if (D.28441 != 0B) goto <D.28442>; else goto <D.28443>;
      <D.28442>:
      D.28263 = (long unsigned int) i;
      D.28326 = D.28263 * 32;
      D.28440 = scalar_stack_slots + D.28326;
      D.28441 = D.28440->active;
      monoeg_g_list_free (D.28441);
      <D.28443>:
      i = i + 1;
      <D.25492>:
      if (i <= 68) goto <D.25491>; else goto <D.25493>;
      <D.25493>:
      i = 0;
      goto <D.25495>;
      <D.25494>:
      D.28263 = (long unsigned int) i;
      D.28326 = D.28263 * 32;
      D.28327 = vtype_stack_slots + D.28326;
      D.28444 = D.28327->active;
      if (D.28444 != 0B) goto <D.28445>; else goto <D.28446>;
      <D.28445>:
      D.28263 = (long unsigned int) i;
      D.28326 = D.28263 * 32;
      D.28327 = vtype_stack_slots + D.28326;
      D.28444 = D.28327->active;
      monoeg_g_list_free (D.28444);
      <D.28446>:
      i = i + 1;
      <D.25495>:
      if (i < nvtypes) goto <D.25494>; else goto <D.25496>;
      <D.25496>:
      D.28447 = cfg->stat_locals_stack_size;
      D.28448 = D.28447 + offset;
      cfg->stat_locals_stack_size = D.28448;
      offset.51 = (unsigned int) offset;
      *stack_size = offset.51;
      D.28449 = offsets;
      return D.28449;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.28454;
  struct MonoLiveInterval * D.28456;
  struct MonoLiveRange2 * D.28457;
  struct MonoLiveInterval * D.28459;
  struct MonoLiveRange2 * D.28460;
  int D.28462;
  int D.28463;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.28452>; else goto <D.28453>;
  <D.28452>:
  D.28454 = 0;
  return D.28454;
  <D.28453>:
  D.28456 = v1->interval;
  D.28457 = D.28456->range;
  if (D.28457 != 0B) goto <D.28458>; else goto <D.28455>;
  <D.28458>:
  D.28459 = v2->interval;
  D.28460 = D.28459->range;
  if (D.28460 != 0B) goto <D.28461>; else goto <D.28455>;
  <D.28461>:
  D.28456 = v1->interval;
  D.28457 = D.28456->range;
  D.28462 = D.28457->from;
  D.28459 = v2->interval;
  D.28460 = D.28459->range;
  D.28463 = D.28460->from;
  D.28454 = D.28462 - D.28463;
  return D.28454;
  <D.28455>:
  D.28456 = v1->interval;
  D.28457 = D.28456->range;
  if (D.28457 != 0B) goto <D.28464>; else goto <D.28465>;
  <D.28464>:
  D.28454 = -1;
  return D.28454;
  <D.28465>:
  D.28454 = 1;
  return D.28454;
}


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

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


mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.52;
  _Bool D.28470;
  long int D.28471;
  long int D.28472;
  int D.28475;
  unsigned char D.28476;
  int D.28477;
  int D.28478;
  int D.28479;
  int D.28480;
  short int * emul_opcode_opcodes.53;
  long unsigned int D.28484;
  long unsigned int D.28485;
  short int * D.28486;
  short int D.28487;
  int D.28488;
  struct MonoJitICallInfo * D.28491;
  struct MonoJitICallInfo * * emul_opcode_map.54;
  long unsigned int D.28493;
  struct MonoJitICallInfo * * D.28494;
  short int emul_opcode_num.55;
  int D.28496;

  opcode.52 = (unsigned int) opcode;
  D.28470 = opcode.52 > 1076;
  D.28471 = (long int) D.28470;
  D.28472 = __builtin_expect (D.28471, 0);
  if (D.28472 != 0) goto <D.28473>; else goto <D.28474>;
  <D.28473>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2356, "opcode >= 0 && opcode <= OP_LAST");
  <D.28474>:
  D.28475 = opcode >> 6;
  D.28476 = emul_opcode_hit_cache[D.28475];
  D.28477 = (int) D.28476;
  D.28478 = opcode & 7;
  D.28479 = D.28477 >> D.28478;
  D.28480 = D.28479 & 1;
  if (D.28480 != 0) goto <D.28481>; else goto <D.28482>;
  <D.28481>:
  {
    int i;

    i = 0;
    goto <D.25570>;
    <D.25569>:
    emul_opcode_opcodes.53 = emul_opcode_opcodes;
    D.28484 = (long unsigned int) i;
    D.28485 = D.28484 * 2;
    D.28486 = emul_opcode_opcodes.53 + D.28485;
    D.28487 = *D.28486;
    D.28488 = (int) D.28487;
    if (D.28488 == opcode) goto <D.28489>; else goto <D.28490>;
    <D.28489>:
    emul_opcode_map.54 = emul_opcode_map;
    D.28484 = (long unsigned int) i;
    D.28493 = D.28484 * 8;
    D.28494 = emul_opcode_map.54 + D.28493;
    D.28491 = *D.28494;
    return D.28491;
    <D.28490>:
    i = i + 1;
    <D.25570>:
    emul_opcode_num.55 = emul_opcode_num;
    D.28496 = (int) emul_opcode_num.55;
    if (D.28496 > i) goto <D.25569>; else goto <D.25571>;
    <D.25571>:
  }
  <D.28482>:
  D.28491 = 0B;
  return D.28491;
}


mono_bblock_add_inst (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.28498;

  D.28498 = bb->last_ins;
  if (D.28498 != 0B) goto <D.28499>; else goto <D.28500>;
  <D.28499>:
  D.28498 = bb->last_ins;
  D.28498->next = inst;
  D.28498 = bb->last_ins;
  inst->prev = D.28498;
  bb->last_ins = inst;
  goto <D.28501>;
  <D.28500>:
  bb->last_ins = inst;
  D.28498 = bb->last_ins;
  bb->code = D.28498;
  <D.28501>:
}


mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28506;
  struct MonoInst * D.28510;

  if (ins == 0B) goto <D.28502>; else goto <D.28503>;
  <D.28502>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.28504>; else goto <D.28505>;
  <D.28504>:
  ins->prev = ins_to_insert;
  <D.28505>:
  D.28506 = bb->last_ins;
  if (D.28506 == 0B) goto <D.28507>; else goto <D.28508>;
  <D.28507>:
  bb->last_ins = ins_to_insert;
  <D.28508>:
  goto <D.28509>;
  <D.28503>:
  D.28510 = ins->next;
  ins_to_insert->next = D.28510;
  D.28510 = ins->next;
  if (D.28510 != 0B) goto <D.28511>; else goto <D.28512>;
  <D.28511>:
  D.28510 = ins->next;
  D.28510->prev = ins_to_insert;
  <D.28512>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.28506 = bb->last_ins;
  if (D.28506 == ins) goto <D.28513>; else goto <D.28514>;
  <D.28513>:
  bb->last_ins = ins_to_insert;
  <D.28514>:
  <D.28509>:
}


mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28519;
  struct MonoInst * D.28523;
  struct MonoInst * D.28526;

  if (ins == 0B) goto <D.28515>; else goto <D.28516>;
  <D.28515>:
  ins = bb->code;
  if (ins != 0B) goto <D.28517>; else goto <D.28518>;
  <D.28517>:
  ins->prev = ins_to_insert;
  <D.28518>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.28519 = bb->last_ins;
  if (D.28519 == 0B) goto <D.28520>; else goto <D.28521>;
  <D.28520>:
  bb->last_ins = ins_to_insert;
  <D.28521>:
  goto <D.28522>;
  <D.28516>:
  D.28523 = ins->prev;
  if (D.28523 != 0B) goto <D.28524>; else goto <D.28525>;
  <D.28524>:
  D.28523 = ins->prev;
  D.28523->next = ins_to_insert;
  <D.28525>:
  D.28523 = ins->prev;
  ins_to_insert->prev = D.28523;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.28526 = bb->code;
  if (D.28526 == ins) goto <D.28527>; else goto <D.28528>;
  <D.28527>:
  bb->code = ins_to_insert;
  <D.28528>:
  <D.28522>:
}


mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.28529;
  _Bool D.28530;
  long int D.28531;
  long int D.28532;
  struct MonoInst * D.28535;
  struct MonoInst * D.28538;
  _Bool D.28539;
  long int D.28540;
  long int D.28541;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.25638>;
  <D.25637>:
  D.28529 = ins->prev;
  D.28530 = D.28529 != prev;
  D.28531 = (long int) D.28530;
  D.28532 = __builtin_expect (D.28531, 0);
  if (D.28532 != 0) goto <D.28533>; else goto <D.28534>;
  <D.28533>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.28534>:
  prev = ins;
  ins = ins->next;
  <D.25638>:
  if (ins != 0B) goto <D.25637>; else goto <D.25639>;
  <D.25639>:
  D.28535 = bb->last_ins;
  if (D.28535 != 0B) goto <D.28536>; else goto <D.28537>;
  <D.28536>:
  D.28535 = bb->last_ins;
  D.28538 = D.28535->next;
  D.28539 = D.28538 != 0B;
  D.28540 = (long int) D.28539;
  D.28541 = __builtin_expect (D.28540, 0);
  if (D.28541 != 0) goto <D.28542>; else goto <D.28543>;
  <D.28542>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.28543>:
  <D.28537>:
}


mono_verify_cfg (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.25645>;
  <D.25644>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.25645>:
  if (bb != 0B) goto <D.25644>; else goto <D.25646>;
  <D.25646>:
}


mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.28544;
  struct MonoRegState * D.28547;
  struct GHashTable * D.28550;
  struct GHashTable * D.28553;
  void * D.28556;
  struct GList * D.28557;
  struct GHashTable * D.28558;
  struct GHashTable * D.28559;
  struct MonoMemPool * D.28562;
  struct MonoInst * * D.28563;
  struct MonoMethodVar * D.28564;
  char * D.28565;
  struct GSList * l;

  D.28544 = cfg->header;
  if (D.28544 != 0B) goto <D.28545>; else goto <D.28546>;
  <D.28545>:
  D.28544 = cfg->header;
  mono_metadata_free_mh (D.28544);
  <D.28546>:
  mono_free_loop_info (cfg);
  D.28547 = cfg->rs;
  if (D.28547 != 0B) goto <D.28548>; else goto <D.28549>;
  <D.28548>:
  D.28547 = cfg->rs;
  mono_regstate_free (D.28547);
  <D.28549>:
  D.28550 = cfg->spvars;
  if (D.28550 != 0B) goto <D.28551>; else goto <D.28552>;
  <D.28551>:
  D.28550 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.28550);
  <D.28552>:
  D.28553 = cfg->exvars;
  if (D.28553 != 0B) goto <D.28554>; else goto <D.28555>;
  <D.28554>:
  D.28553 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.28553);
  <D.28555>:
  l = cfg->headers_to_free;
  goto <D.25652>;
  <D.25651>:
  D.28556 = l->data;
  mono_metadata_free_mh (D.28556);
  l = l->next;
  <D.25652>:
  if (l != 0B) goto <D.25651>; else goto <D.25653>;
  <D.25653>:
  D.28557 = cfg->ldstr_list;
  monoeg_g_list_free (D.28557);
  D.28558 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.28558);
  D.28559 = cfg->abs_patches;
  if (D.28559 != 0B) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  D.28559 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.28559);
  <D.28561>:
  D.28562 = cfg->mempool;
  mono_mempool_destroy (D.28562);
  mono_debug_free_method (cfg);
  D.28563 = cfg->varinfo;
  monoeg_g_free (D.28563);
  D.28564 = cfg->vars;
  monoeg_g_free (D.28564);
  D.28565 = cfg->exception_message;
  monoeg_g_free (D.28565);
  monoeg_g_free (cfg);
}


mono_get_jit_tls_key ()
{
  pthread_key_t D.28566;

  D.28566 = mono_jit_tls_id;
  return D.28566;
}


mono_get_jit_tls_offset ()
{
  gint32 D.28568;
  int offset;

  {
    guint64 foo;

    __asm__("movq $mono_jit_tls@TPOFF, %0" : "=r" foo);
    offset = (int) foo;
  }
  D.28568 = offset;
  return D.28568;
}


mono_get_lmf_tls_offset ()
{
  gint32 D.28570;
  int offset;

  {
    guint64 foo;

    __asm__("movq $mono_lmf@TPOFF, %0" : "=r" foo);
    offset = (int) foo;
  }
  D.28570 = offset;
  return D.28570;
}


mono_get_lmf_addr_tls_offset ()
{
  gint32 D.28572;
  int offset;

  {
    guint64 foo;

    __asm__("movq $mono_lmf_addr@TPOFF, %0" : "=r" foo);
    offset = (int) foo;
  }
  D.28572 = offset;
  return D.28572;
}


mono_get_lmf ()
{
  struct MonoLMF * D.28574;

  D.28574 = mono_lmf;
  return D.28574;
}


mono_get_lmf_addr ()
{
  struct MonoLMF * * D.28576;

  D.28576 = mono_lmf_addr;
  return D.28576;
}


mono_set_lmf (struct MonoLMF * lmf)
{
  struct MonoLMF * * D.28578;

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


mono_jit_thread_attach (struct MonoDomain * domain)
{
  void * mono_lmf_addr.56;
  struct MonoInternalThread * D.28584;
  struct MonoDomain * D.28587;
  struct MonoDomain * iftmp.57;
  struct MonoDomain * orig;

  if (domain == 0B) goto <D.28579>; else goto <D.28580>;
  <D.28579>:
  domain = mono_get_root_domain ();
  <D.28580>:
  mono_lmf_addr.56 = mono_lmf_addr;
  if (mono_lmf_addr.56 == 0B) goto <D.28582>; else goto <D.28583>;
  <D.28582>:
  mono_thread_attach (domain);
  D.28584 = mono_thread_internal_current ();
  mono_thread_set_state (D.28584, 4);
  <D.28583>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.28585>; else goto <D.28586>;
  <D.28585>:
  mono_domain_set (domain, 1);
  <D.28586>:
  if (orig != domain) goto <D.28589>; else goto <D.28590>;
  <D.28589>:
  iftmp.57 = orig;
  goto <D.28591>;
  <D.28590>:
  iftmp.57 = 0B;
  <D.28591>:
  D.28587 = iftmp.57;
  return D.28587;
}


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


mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.28595;
  long int D.28596;
  long int D.28597;
  int D.28600;
  int offset;

  switch (key) <default: <D.25740>, case 0: <D.25734>, case 1: <D.25736>, case 2: <D.25737>, case 3: <D.25738>, case 8: <D.25739>>
  <D.25734>:
  offset = mono_thread_get_tls_offset ();
  goto <D.25735>;
  <D.25736>:
  offset = mono_get_jit_tls_offset ();
  goto <D.25735>;
  <D.25737>:
  offset = mono_domain_get_tls_offset ();
  goto <D.25735>;
  <D.25738>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.25735>;
  <D.25739>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.25735>;
  <D.25740>:
  offset = mono_tls_key_get_offset (key);
  D.28595 = offset == -1;
  D.28596 = (long int) D.28595;
  D.28597 = __builtin_expect (D.28596, 0);
  if (D.28597 != 0) goto <D.28598>; else goto <D.28599>;
  <D.28598>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.28599>:
  goto <D.25735>;
  <D.25735>:
  D.28600 = offset;
  return D.28600;
}


mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  int D.28602;
  gboolean D.28605;
  unsigned char D.28606;
  unsigned char D.28607;
  int D.28610;
  _Bool D.28611;

  D.28602 = mono_amd64_have_tls_get ();
  if (D.28602 == 0) goto <D.28603>; else goto <D.28604>;
  <D.28603>:
  D.28605 = 0;
  return D.28605;
  <D.28604>:
  D.28606 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.28607 = D.28606 & 64;
  if (D.28607 != 0) goto <D.28608>; else goto <D.28609>;
  <D.28608>:
  D.28605 = 1;
  return D.28605;
  <D.28609>:
  D.28610 = mini_get_tls_offset (key);
  D.28611 = D.28610 != -1;
  D.28605 = (gboolean) D.28611;
  return D.28605;
}


mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  unsigned char D.28613;
  unsigned char D.28614;
  int D.28618;
  struct MonoMemPool * D.28623;
  long int D.28624;
  struct MonoInst * D.28625;
  guint16 iftmp.58;
  int D.28630;
  int D.28631;
  const unsigned char * D.28632;
  long int D.28633;
  void * D.28634;
  unsigned int D.28635;
  int D.28636;
  long int D.28638;
  void * D.28639;
  unsigned int D.28640;
  int D.28641;
  struct MonoBasicBlock * D.28642;
  struct MonoInst * D.28643;
  long int D.28647;
  struct MonoInst * D.28648;
  int D.28649;
  int D.28650;
  unsigned int D.28651;
  int D.28652;
  int D.28653;
  struct MonoInst * D.28654;
  int D.28655;

  D.28613 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.28614 = D.28613 & 64;
  if (D.28614 != 0) goto <D.28615>; else goto <D.28616>;
  <D.28615>:
  D.28618 = mono_amd64_have_tls_get ();
  if (D.28618 != 0) goto <D.28619>; else goto <D.28617>;
  <D.28619>:
  if (1 != 0) goto <D.28620>; else goto <D.28617>;
  <D.28620>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.28613 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.28614 = D.28613 & 64;
    if (D.28614 != 0) goto <D.28621>; else goto <D.28622>;
    <D.28621>:
    D.28623 = cfg->mempool;
    c = mono_mempool_alloc (D.28623, 80);
    c->data.op[1].const_val = 0;
    D.28624 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.28624;
    c->prev = 0B;
    D.28625 = c->prev;
    c->next = D.28625;
    D.28613 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.28614 = D.28613 & 64;
    if (D.28614 != 0) goto <D.28627>; else goto <D.28628>;
    <D.28627>:
    iftmp.58 = 736;
    goto <D.28629>;
    <D.28628>:
    iftmp.58 = 363;
    <D.28629>:
    c->opcode = iftmp.58;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.28630 = c->sreg3;
    c->sreg2 = D.28630;
    D.28631 = c->sreg2;
    c->sreg1 = D.28631;
    D.28632 = cfg->ip;
    c->cil_code = D.28632;
    D.28633 = (long int) key;
    D.28634 = (void *) D.28633;
    c->data.op[0].p = D.28634;
    c->data.op[1].src = 48B;
    c->type = 3;
    D.28635 = alloc_dreg (cfg, 3);
    D.28636 = (int) D.28635;
    c->dreg = D.28636;
    goto <D.28637>;
    <D.28622>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.28623 = cfg->mempool;
      c = mono_mempool_alloc (D.28623, 80);
      c->data.op[1].const_val = 0;
      D.28624 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.28624;
      c->prev = 0B;
      D.28625 = c->prev;
      c->next = D.28625;
      c->opcode = 363;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.28630 = c->sreg3;
      c->sreg2 = D.28630;
      D.28631 = c->sreg2;
      c->sreg1 = D.28631;
      D.28632 = cfg->ip;
      c->cil_code = D.28632;
      D.28638 = (long int) _offset;
      D.28639 = (void *) D.28638;
      c->data.op[0].p = D.28639;
      c->type = 3;
      D.28640 = alloc_dreg (cfg, 3);
      D.28641 = (int) D.28640;
      c->dreg = D.28641;
    }
    <D.28637>:
    D.28642 = cfg->cbb;
    D.28643 = D.28642->last_ins;
    if (D.28643 != 0B) goto <D.28644>; else goto <D.28645>;
    <D.28644>:
    D.28642 = cfg->cbb;
    D.28643 = D.28642->last_ins;
    D.28643->next = c;
    D.28642 = cfg->cbb;
    D.28643 = D.28642->last_ins;
    c->prev = D.28643;
    D.28642 = cfg->cbb;
    D.28642->last_ins = c;
    goto <D.28646>;
    <D.28645>:
    D.28642 = cfg->cbb;
    D.28642 = cfg->cbb;
    D.28642->last_ins = c;
    D.28643 = D.28642->last_ins;
    D.28642->code = D.28643;
    <D.28646>:
    D.28623 = cfg->mempool;
    ins = mono_mempool_alloc (D.28623, 80);
    ins->data.op[1].const_val = 0;
    D.28647 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.28647;
    ins->prev = 0B;
    D.28648 = ins->prev;
    ins->next = D.28648;
    ins->opcode = 796;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.28649 = ins->sreg3;
    ins->sreg2 = D.28649;
    D.28650 = ins->sreg2;
    ins->sreg1 = D.28650;
    D.28632 = cfg->ip;
    ins->cil_code = D.28632;
    D.28651 = mono_alloc_preg (cfg);
    D.28652 = (int) D.28651;
    ins->dreg = D.28652;
    D.28653 = c->dreg;
    ins->sreg1 = D.28653;
    D.28654 = ins;
    return D.28654;
  }
  <D.28617>:
  D.28654 = 0B;
  return D.28654;
  <D.28616>:
  D.28655 = mini_get_tls_offset (key);
  D.28654 = mono_create_tls_get_offset (cfg, D.28655);
  return D.28654;
}


alloc_dreg (struct MonoCompile * cfg, MonoStackType stack_type)
{
  guint32 D.28657;

  switch (stack_type) <default: <D.24573>, case 1: <D.24566>, case 2: <D.24571>, case 3: <D.24567>, case 4: <D.24570>, case 5: <D.24568>, case 6: <D.24569>, case 7: <D.24572>>
  <D.24566>:
  <D.24567>:
  D.28657 = alloc_ireg (cfg);
  return D.28657;
  <D.24568>:
  D.28657 = alloc_ireg_mp (cfg);
  return D.28657;
  <D.24569>:
  D.28657 = alloc_ireg_ref (cfg);
  return D.28657;
  <D.24570>:
  D.28657 = alloc_freg (cfg);
  return D.28657;
  <D.24571>:
  D.28657 = alloc_lreg (cfg);
  return D.28657;
  <D.24572>:
  D.28657 = alloc_ireg (cfg);
  return D.28657;
  <D.24573>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.28657 = 4294967295;
  return D.28657;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.28659;
  unsigned char D.28660;
  unsigned char D.28661;
  guint32 D.28664;
  int vreg;

  D.28659 = alloc_ireg (cfg);
  vreg = (int) D.28659;
  D.28660 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.28661 = D.28660 & 128;
  if (D.28661 != 0) goto <D.28662>; else goto <D.28663>;
  <D.28662>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.28663>:
  D.28664 = (guint32) vreg;
  return D.28664;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.28666;
  unsigned char D.28667;
  unsigned char D.28668;
  guint32 D.28671;
  int vreg;

  D.28666 = alloc_ireg (cfg);
  vreg = (int) D.28666;
  D.28667 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.28668 = D.28667 & 128;
  if (D.28668 != 0) goto <D.28669>; else goto <D.28670>;
  <D.28669>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.28670>:
  D.28671 = (guint32) vreg;
  return D.28671;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.28673;
  guint32 D.28676;
  unsigned int D.28677;
  unsigned int D.28678;
  unsigned int D.28679;

  D.28673 = mono_arch_is_soft_float ();
  if (D.28673 != 0) goto <D.28674>; else goto <D.28675>;
  <D.28674>:
  D.28676 = alloc_lreg (cfg);
  return D.28676;
  <D.28675>:
  D.28677 = cfg->next_vreg;
  D.28678 = D.28677;
  D.28679 = D.28678 + 1;
  cfg->next_vreg = D.28679;
  D.28676 = D.28678;
  return D.28676;
}


alloc_lreg (struct MonoCompile * cfg)
{
  guint32 D.28681;
  unsigned int D.28682;
  unsigned int D.28683;
  unsigned int D.28684;

  D.28682 = cfg->next_vreg;
  D.28683 = D.28682;
  D.28684 = D.28683 + 1;
  cfg->next_vreg = D.28684;
  D.28681 = D.28683;
  return D.28681;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.28686;
  unsigned int D.28687;
  unsigned int D.28688;
  unsigned int D.28689;

  D.28687 = cfg->next_vreg;
  D.28688 = D.28687;
  D.28689 = D.28688 + 1;
  cfg->next_vreg = D.28689;
  D.28686 = D.28688;
  return D.28686;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  int D.28691;
  struct MonoInst * D.28694;
  struct MonoMemPool * D.28697;
  long int D.28698;
  struct MonoInst * D.28699;
  int D.28700;
  int D.28701;
  const unsigned char * D.28702;
  unsigned int D.28703;
  int D.28704;
  long int D.28705;
  struct MonoInst * ins;

  D.28691 = mono_amd64_have_tls_get ();
  if (D.28691 == 0) goto <D.28692>; else goto <D.28693>;
  <D.28692>:
  D.28694 = 0B;
  return D.28694;
  <D.28693>:
  if (offset == -1) goto <D.28695>; else goto <D.28696>;
  <D.28695>:
  D.28694 = 0B;
  return D.28694;
  <D.28696>:
  D.28697 = cfg->mempool;
  ins = mono_mempool_alloc (D.28697, 80);
  ins->data.op[1].const_val = 0;
  D.28698 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.28698;
  ins->prev = 0B;
  D.28699 = ins->prev;
  ins->next = D.28699;
  ins->opcode = 795;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28700 = ins->sreg3;
  ins->sreg2 = D.28700;
  D.28701 = ins->sreg2;
  ins->sreg1 = D.28701;
  D.28702 = cfg->ip;
  ins->cil_code = D.28702;
  D.28703 = mono_alloc_preg (cfg);
  D.28704 = (int) D.28703;
  ins->dreg = D.28704;
  D.28705 = (long int) offset;
  ins->data.op[0].const_val = D.28705;
  D.28694 = ins;
  return D.28694;
}


mono_get_jit_tls_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28707;

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


mono_get_domain_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28709;

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


mono_get_thread_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28711;

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


mono_get_lmf_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28713;

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


mono_get_lmf_addr_intrinsic (struct MonoCompile * cfg)
{
  struct MonoInst * D.28715;

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


mono_add_patch_info (struct MonoCompile * cfg, int ip, MonoJumpInfoType type, const void * target)
{
  struct MonoMemPool * D.28717;
  struct MonoJumpInfo * D.28718;
  struct MonoJumpInfo * ji;

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


mono_add_patch_info_rel (struct MonoCompile * cfg, int ip, MonoJumpInfoType type, const void * target, int relocation)
{
  struct MonoMemPool * D.28719;
  struct MonoJumpInfo * D.28720;
  struct MonoJumpInfo * ji;

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


mono_patch_info_list_prepend (struct MonoJumpInfo * list, int ip, MonoJumpInfoType type, const void * target)
{
  struct MonoJumpInfo * D.28721;
  struct MonoJumpInfo * ji;

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


mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.28723;
  int D.28724;
  struct MonoJumpInfo * D.28727;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.25800>;
  <D.25799>:
  D.28723 = *ji;
  D.28724 = D.28723->ip.i;
  if (D.28724 == ip) goto <D.28725>; else goto <D.28726>;
  <D.28725>:
  D.28723 = *ji;
  D.28727 = D.28723->next;
  *ji = D.28727;
  goto <D.28728>;
  <D.28726>:
  D.28723 = *ji;
  ji = &D.28723->next;
  <D.28728>:
  <D.25800>:
  D.28723 = *ji;
  if (D.28723 != 0B) goto <D.25799>; else goto <D.25801>;
  <D.25801>:
}


mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.28729;
  void * D.28730;
  struct MonoJumpInfoToken * D.28731;
  struct MonoJumpInfoToken * D.28732;
  void * D.28733;
  struct MonoJumpInfoBBTable * D.28734;
  struct MonoJumpInfoBBTable * D.28735;
  int D.28736;
  long unsigned int D.28737;
  unsigned int D.28738;
  unsigned int D.28739;
  void * D.28740;
  long unsigned int D.28741;
  struct MonoBasicBlock * * D.28742;
  struct MonoBasicBlock * * D.28743;
  void * D.28744;
  struct MonoJumpInfoRgctxEntry * D.28745;
  struct MonoJumpInfoRgctxEntry * D.28746;
  struct MonoJumpInfo * D.28747;
  struct MonoJumpInfo * D.28748;
  void * D.28749;
  struct MonoJumpInfoGSharedVtCall * D.28750;
  struct MonoJumpInfoGSharedVtCall * D.28751;
  struct GPtrArray * D.28752;
  struct GPtrArray * D.28753;
  void * * D.28756;
  long unsigned int D.28757;
  long unsigned int D.28758;
  void * * D.28759;
  struct GPtrArray * D.28760;
  unsigned int i.59;
  unsigned int D.28762;
  struct MonoJumpInfo * D.28763;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 40);
  memcpy (res, patch_info, 40);
  D.28729 = patch_info->type;
  switch (D.28729) <default: <D.25825>, case 8: <D.25813>, case 17: <D.25808>, case 18: <D.25810>, case 19: <D.25809>, case 28: <D.25811>, case 29: <D.25807>, case 35: <D.25814>, case 45: <D.25815>, case 46: <D.25816>>
  <D.25807>:
  <D.25808>:
  <D.25809>:
  <D.25810>:
  <D.25811>:
  D.28730 = mono_mempool_alloc (mp, 32);
  res->data.token = D.28730;
  D.28731 = patch_info->data.token;
  D.28732 = res->data.token;
  memcpy (D.28732, D.28731, 32);
  goto <D.25812>;
  <D.25813>:
  D.28733 = mono_mempool_alloc (mp, 16);
  res->data.table = D.28733;
  D.28734 = patch_info->data.table;
  D.28735 = res->data.table;
  memcpy (D.28735, D.28734, 16);
  D.28735 = res->data.table;
  D.28734 = patch_info->data.table;
  D.28736 = D.28734->table_size;
  D.28737 = (long unsigned int) D.28736;
  D.28738 = (unsigned int) D.28737;
  D.28739 = D.28738 * 8;
  D.28740 = mono_mempool_alloc (mp, D.28739);
  D.28735->table = D.28740;
  D.28734 = patch_info->data.table;
  D.28736 = D.28734->table_size;
  D.28737 = (long unsigned int) D.28736;
  D.28741 = D.28737 * 8;
  D.28734 = patch_info->data.table;
  D.28742 = D.28734->table;
  D.28735 = res->data.table;
  D.28743 = D.28735->table;
  memcpy (D.28743, D.28742, D.28741);
  goto <D.25812>;
  <D.25814>:
  D.28744 = mono_mempool_alloc (mp, 32);
  res->data.rgctx_entry = D.28744;
  D.28745 = patch_info->data.rgctx_entry;
  D.28746 = res->data.rgctx_entry;
  memcpy (D.28746, D.28745, 32);
  D.28746 = res->data.rgctx_entry;
  D.28746 = res->data.rgctx_entry;
  D.28747 = D.28746->data;
  D.28748 = mono_patch_info_dup_mp (mp, D.28747);
  D.28746->data = D.28748;
  goto <D.25812>;
  <D.25815>:
  D.28749 = mono_mempool_alloc (mp, 16);
  res->data.gsharedvt = D.28749;
  D.28750 = patch_info->data.gsharedvt;
  D.28751 = res->data.gsharedvt;
  memcpy (D.28751, D.28750, 16);
  goto <D.25812>;
  <D.25816>:
  {
    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.28752 = monoeg_g_ptr_array_new ();
    info->entries = D.28752;
    D.28753 = oinfo->entries;
    if (D.28753 != 0B) goto <D.28754>; else goto <D.28755>;
    <D.28754>:
    i = 0;
    goto <D.25823>;
    <D.25822>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.28753 = oinfo->entries;
      D.28756 = D.28753->pdata;
      D.28757 = (long unsigned int) i;
      D.28758 = D.28757 * 8;
      D.28759 = D.28756 + D.28758;
      otemplate = *D.28759;
      template = mono_mempool_alloc0 (mp, 24);
      memcpy (template, otemplate, 24);
      D.28760 = info->entries;
      monoeg_g_ptr_array_add (D.28760, template);
    }
    i = i + 1;
    <D.25823>:
    i.59 = (unsigned int) i;
    D.28753 = oinfo->entries;
    D.28762 = D.28753->len;
    if (i.59 < D.28762) goto <D.25822>; else goto <D.25824>;
    <D.25824>:
    <D.28755>:
    goto <D.25812>;
  }
  <D.25825>:
  goto <D.25812>;
  <D.25812>:
  D.28763 = res;
  return D.28763;
}


mono_patch_info_hash (const void * data)
{
  <unnamed type> D.28766;
  guint D.28767;
  unsigned int D.28768;
  struct MonoJumpInfoToken * D.28769;
  unsigned int D.28770;
  unsigned int D.28771;
  guint iftmp.60;
  int D.28773;
  struct MonoGenericInst * D.28776;
  long int D.28777;
  const char * D.28779;
  unsigned int D.28780;
  signed int D.28781;
  const void * D.28782;
  long int D.28783;
  signed int D.28784;
  signed int D.28785;
  struct MonoJumpInfoGSharedVtCall * D.28786;
  struct MonoMethod * D.28787;
  long int D.28788;
  signed int D.28789;
  signed int D.28790;
  struct MonoMethod * D.28791;
  long int D.28792;
  signed int D.28793;
  signed int D.28794;
  int D.28795;
  signed int D.28796;
  <unnamed type> D.28797;
  signed int D.28798;
  signed int D.28799;
  struct MonoJumpInfo * D.28800;
  unsigned int D.28801;
  signed int D.28802;
  signed int D.28803;
  struct MonoJumpInfoBBTable * D.28804;
  int D.28805;
  unsigned int D.28806;
  struct MonoGSharedVtMethodInfo * D.28807;
  struct MonoMethod * D.28808;
  long int D.28809;
  signed int D.28810;
  signed int D.28811;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.28766 = ji->type;
  switch (D.28766) <default: <D.25870>, case 3: <D.25843>, case 4: <D.25844>, case 6: <D.25842>, case 7: <D.25835>, case 8: <D.25867>, case 11: <D.25837>, case 12: <D.25845>, case 13: <D.25848>, case 14: <D.25836>, case 15: <D.25840>, case 16: <D.25849>, case 17: <D.25831>, case 18: <D.25832>, case 19: <D.25834>, case 23: <D.25838>, case 24: <D.25839>, case 27: <D.25866>, case 28: <D.25833>, case 29: <D.25830>, case 30: <D.25852>, case 31: <D.25847>, case 32: <D.25846>, case 33: <D.25859>, case 34: <D.25851>, case 35: <D.25857>, case 36: <D.25841>, case 37: <D.25863>, case 38: <D.25864>, case 39: <D.25860>, case 40: <D.25850>, case 42: <D.25861>, case 43: <D.25865>, case 44: <D.25853>, case 45: <D.25856>, case 46: <D.25868>, case 47: <D.25862>, case 48: <D.25854>, case 49: <D.25869>, case 50: <D.25855>>
  <D.25830>:
  <D.25831>:
  <D.25832>:
  <D.25833>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28769 = ji->data.token;
  D.28770 = D.28769->token;
  D.28767 = D.28768 | D.28770;
  return D.28767;
  <D.25834>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28769 = ji->data.token;
  D.28770 = D.28769->token;
  D.28771 = D.28768 | D.28770;
  D.28769 = ji->data.token;
  D.28773 = D.28769->has_context;
  if (D.28773 != 0) goto <D.28774>; else goto <D.28775>;
  <D.28774>:
  D.28769 = ji->data.token;
  D.28776 = D.28769->context.class_inst;
  D.28777 = (long int) D.28776;
  iftmp.60 = (guint) D.28777;
  goto <D.28778>;
  <D.28775>:
  iftmp.60 = 0;
  <D.28778>:
  D.28767 = D.28771 | iftmp.60;
  return D.28767;
  <D.25835>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28779 = ji->data.name;
  D.28780 = monoeg_g_str_hash (D.28779);
  D.28767 = D.28768 | D.28780;
  return D.28767;
  <D.25836>:
  <D.25837>:
  <D.25838>:
  <D.25839>:
  <D.25840>:
  <D.25841>:
  <D.25842>:
  <D.25843>:
  <D.25844>:
  <D.25845>:
  <D.25846>:
  <D.25847>:
  <D.25848>:
  <D.25849>:
  <D.25850>:
  <D.25851>:
  <D.25852>:
  <D.25853>:
  <D.25854>:
  <D.25855>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28781 = (signed int) D.28768;
  D.28782 = ji->data.target;
  D.28783 = (long int) D.28782;
  D.28784 = (signed int) D.28783;
  D.28785 = D.28781 | D.28784;
  D.28767 = (guint) D.28785;
  return D.28767;
  <D.25856>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28781 = (signed int) D.28768;
  D.28786 = ji->data.gsharedvt;
  D.28787 = D.28786->method;
  D.28788 = (long int) D.28787;
  D.28789 = (signed int) D.28788;
  D.28790 = D.28781 | D.28789;
  D.28767 = (guint) D.28790;
  return D.28767;
  <D.25857>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.28766 = ji->type;
    D.28768 = D.28766 << 8;
    D.28781 = (signed int) D.28768;
    D.28791 = e->method;
    D.28792 = (long int) D.28791;
    D.28793 = (signed int) D.28792;
    D.28794 = D.28781 | D.28793;
    D.28795 = e->in_mrgctx;
    D.28796 = D.28794 | D.28795;
    D.28797 = e->info_type;
    D.28798 = (signed int) D.28797;
    D.28799 = D.28796 | D.28798;
    D.28800 = e->data;
    D.28801 = mono_patch_info_hash (D.28800);
    D.28802 = (signed int) D.28801;
    D.28803 = D.28799 | D.28802;
    D.28767 = (guint) D.28803;
    return D.28767;
  }
  <D.25859>:
  <D.25860>:
  <D.25861>:
  <D.25862>:
  <D.25863>:
  <D.25864>:
  <D.25865>:
  <D.25866>:
  D.28766 = ji->type;
  D.28767 = D.28766 << 8;
  return D.28767;
  <D.25867>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28804 = ji->data.table;
  D.28805 = D.28804->table_size;
  D.28806 = (unsigned int) D.28805;
  D.28767 = D.28768 | D.28806;
  return D.28767;
  <D.25868>:
  D.28766 = ji->type;
  D.28768 = D.28766 << 8;
  D.28781 = (signed int) D.28768;
  D.28807 = ji->data.gsharedvt_method;
  D.28808 = D.28807->method;
  D.28809 = (long int) D.28808;
  D.28810 = (signed int) D.28809;
  D.28811 = D.28781 | D.28810;
  D.28767 = (guint) D.28811;
  return D.28767;
  <D.25869>:
  D.28782 = ji->data.target;
  D.28767 = monoeg_g_str_hash (D.28782);
  return D.28767;
  <D.25870>:
  D.28766 = ji->type;
  printf ("info type: %d\n", D.28766);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.28767 = 0;
  return D.28767;
}


mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.28813;
  <unnamed type> D.28814;
  gint D.28817;
  struct MonoJumpInfoToken * D.28820;
  struct MonoImage * D.28821;
  struct MonoJumpInfoToken * D.28822;
  struct MonoImage * D.28823;
  long unsigned int D.28825;
  long unsigned int D.28826;
  long unsigned int D.28827;
  long unsigned int D.28828;
  struct MonoGenericInst * D.28830;
  struct MonoGenericInst * D.28831;
  struct MonoGenericInst * D.28833;
  struct MonoGenericInst * D.28834;
  const char * D.28835;
  const char * D.28836;
  int iftmp.61;
  struct MonoMethod * D.28840;
  struct MonoMethod * D.28841;
  int D.28843;
  int D.28844;
  <unnamed type> D.28846;
  <unnamed type> D.28847;
  struct MonoJumpInfo * D.28849;
  struct MonoJumpInfo * D.28850;
  int D.28851;
  int iftmp.62;
  struct MonoMethodSignature * D.28856;
  struct MonoMethodSignature * D.28857;
  struct MonoMethod * D.28859;
  struct MonoMethod * D.28860;
  struct MonoGSharedVtMethodInfo * D.28862;
  struct MonoMethod * D.28863;
  struct MonoGSharedVtMethodInfo * D.28864;
  struct MonoMethod * D.28865;
  _Bool D.28866;
  const void * D.28867;
  const void * D.28868;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.28813 = ji1->type;
  D.28814 = ji2->type;
  if (D.28813 != D.28814) goto <D.28815>; else goto <D.28816>;
  <D.28815>:
  D.28817 = 0;
  return D.28817;
  <D.28816>:
  D.28813 = ji1->type;
  switch (D.28813) <default: <D.25891>, case 7: <D.25883>, case 17: <D.25878>, case 18: <D.25880>, case 19: <D.25879>, case 28: <D.25881>, case 29: <D.25877>, case 35: <D.25884>, case 45: <D.25887>, case 46: <D.25890>>
  <D.25877>:
  <D.25878>:
  <D.25879>:
  <D.25880>:
  <D.25881>:
  D.28820 = ji1->data.token;
  D.28821 = D.28820->image;
  D.28822 = ji2->data.token;
  D.28823 = D.28822->image;
  if (D.28821 != D.28823) goto <D.28818>; else goto <D.28824>;
  <D.28824>:
  D.28820 = ji1->data.token;
  D.28825 = BIT_FIELD_REF <*D.28820, 64, 64>;
  D.28826 = D.28825;
  D.28822 = ji2->data.token;
  D.28827 = BIT_FIELD_REF <*D.28822, 64, 64>;
  D.28828 = D.28827;
  if (D.28826 != D.28828) goto <D.28818>; else goto <D.28829>;
  <D.28829>:
  D.28820 = ji1->data.token;
  D.28830 = D.28820->context.class_inst;
  D.28822 = ji2->data.token;
  D.28831 = D.28822->context.class_inst;
  if (D.28830 != D.28831) goto <D.28818>; else goto <D.28832>;
  <D.28832>:
  D.28820 = ji1->data.token;
  D.28833 = D.28820->context.method_inst;
  D.28822 = ji2->data.token;
  D.28834 = D.28822->context.method_inst;
  if (D.28833 != D.28834) goto <D.28818>; else goto <D.28819>;
  <D.28818>:
  D.28817 = 0;
  return D.28817;
  <D.28819>:
  goto <D.25882>;
  <D.25883>:
  D.28835 = ji2->data.name;
  D.28836 = ji1->data.name;
  D.28817 = monoeg_g_str_equal (D.28836, D.28835);
  return D.28817;
  <D.25884>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.28840 = e1->method;
    D.28841 = e2->method;
    if (D.28840 == D.28841) goto <D.28842>; else goto <D.28838>;
    <D.28842>:
    D.28843 = e1->in_mrgctx;
    D.28844 = e2->in_mrgctx;
    if (D.28843 == D.28844) goto <D.28845>; else goto <D.28838>;
    <D.28845>:
    D.28846 = e1->info_type;
    D.28847 = e2->info_type;
    if (D.28846 == D.28847) goto <D.28848>; else goto <D.28838>;
    <D.28848>:
    D.28849 = e2->data;
    D.28850 = e1->data;
    D.28851 = mono_patch_info_equal (D.28850, D.28849);
    if (D.28851 != 0) goto <D.28852>; else goto <D.28838>;
    <D.28852>:
    iftmp.61 = 1;
    goto <D.28839>;
    <D.28838>:
    iftmp.61 = 0;
    <D.28839>:
    D.28817 = iftmp.61;
    return D.28817;
  }
  <D.25887>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.28856 = c1->sig;
    D.28857 = c2->sig;
    if (D.28856 == D.28857) goto <D.28858>; else goto <D.28854>;
    <D.28858>:
    D.28859 = c1->method;
    D.28860 = c2->method;
    if (D.28859 == D.28860) goto <D.28861>; else goto <D.28854>;
    <D.28861>:
    iftmp.62 = 1;
    goto <D.28855>;
    <D.28854>:
    iftmp.62 = 0;
    <D.28855>:
    D.28817 = iftmp.62;
    return D.28817;
  }
  <D.25890>:
  D.28862 = ji1->data.gsharedvt_method;
  D.28863 = D.28862->method;
  D.28864 = ji2->data.gsharedvt_method;
  D.28865 = D.28864->method;
  D.28866 = D.28863 == D.28865;
  D.28817 = (gint) D.28866;
  return D.28817;
  <D.25891>:
  D.28867 = ji1->data.target;
  D.28868 = ji2->data.target;
  if (D.28867 != D.28868) goto <D.28869>; else goto <D.28870>;
  <D.28869>:
  D.28817 = 0;
  return D.28817;
  <D.28870>:
  goto <D.25882>;
  <D.25882>:
  D.28817 = 1;
  return D.28817;
}


mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.28872;
  sizetype D.28873;
  <unnamed type> D.28874;
  struct MonoBasicBlock * D.28875;
  int D.28876;
  sizetype D.28877;
  struct MonoInst * D.28878;
  long int D.28879;
  sizetype D.28880;
  long int D.28881;
  sizetype D.28882;
  const char * D.28883;
  struct MonoMethod * D.28888;
  union mono_mutex_t * D.28892;
  _Bool D.28895;
  long int D.28896;
  long int D.28897;
  void * D.28900;
  struct GHashTable * D.28901;
  struct GHashTable * D.28904;
  _Bool D.28909;
  long int D.28910;
  long int D.28911;
  unsigned char D.28917;
  unsigned char D.28918;
  struct MonoJumpInfoBBTable * D.28920;
  int D.28921;
  unsigned int D.28922;
  unsigned int D.28923;
  int D.28924;
  struct MonoJitDynamicMethodInfo * D.28925;
  struct MonoCodeManager * D.28926;
  int mono_aot_only.63;
  long unsigned int D.28930;
  unsigned int D.28931;
  unsigned int D.28932;
  long unsigned int D.28934;
  long unsigned int D.28935;
  void * * D.28936;
  struct MonoBasicBlock * * D.28937;
  struct MonoBasicBlock * * D.28938;
  struct MonoBasicBlock * D.28939;
  long int D.28940;
  int D.28941;
  sizetype D.28942;
  void * D.28943;
  struct MonoClass * D.28944;
  short unsigned int D.28945;
  long int D.28946;
  int D.28947;
  int D.28948;
  int D.28949;
  long int D.28950;
  _Bool D.28951;
  long int D.28952;
  long int D.28953;
  _Bool D.28956;
  long int D.28957;
  long int D.28958;
  struct MonoClassField * D.28961;
  struct MonoClass * D.28962;
  int D.28963;
  _Bool D.28968;
  long int D.28969;
  long int D.28970;
  struct GHashTable * D.28973;
  _Bool D.28978;
  long int D.28979;
  long int D.28980;
  _Bool D.28983;
  long int D.28984;
  long int D.28985;
  void * D.28988;
  _Bool D.28989;
  long int D.28990;
  long int D.28991;
  unsigned char D.28996;
  unsigned char D.28997;
  struct MonoClass * D.28999;
  unsigned int D.29000;
  unsigned int D.29001;
  int D.29004;
  void * D.29008;
  int D.29009;
  sizetype D.29010;
  struct MonoJumpInfoToken * D.29011;
  unsigned int D.29012;
  unsigned int D.29013;
  struct MonoImage * D.29014;
  unsigned int rva.64;
  unsigned int D.29016;
  struct MonoGenericContext * iftmp.65;
  int D.29018;
  struct MonoClass * handle_class.66;
  struct MonoClass * D.29023;
  struct MonoGenericContext * iftmp.67;
  struct MonoClass * handle_class.68;
  const char * D.29029;
  short unsigned int D.29030;
  int D.29031;
  int D.29032;
  const char * exc_arg.69;
  const char * exc_class.70;
  struct MonoImage * D.29043;
  struct MonoException * D.29044;
  char * D.29045;
  _Bool D.29048;
  _Bool D.29049;
  char * D.29052;
  struct MonoClass * D.29053;
  _Bool D.29054;
  long int D.29055;
  long int D.29056;
  struct MonoGenericContext * D.29059;
  struct MonoGenericInst * D.29060;
  struct MonoJumpInfo * D.29061;
  <unnamed type> D.29062;
  struct MonoMethod * D.29063;
  struct MonoGenericContext * D.29064;
  <unnamed type> D.29065;
  struct MonoClass * D.29066;
  struct MonoType * D.29067;
  int D.29068;
  struct MonoGenericContext * D.29069;
  struct MonoMethod * D.29070;
  struct MonoGenericContext * D.29071;
  struct MonoClassField * D.29072;
  struct MonoGenericContext * D.29073;
  struct MonoMethodSignature * D.29074;
  struct MonoJumpInfoGSharedVtCall * D.29075;
  struct MonoGenericContext * D.29076;
  struct MonoMethod * D.29077;
  struct GPtrArray * D.29078;
  struct GPtrArray * D.29079;
  void * * D.29080;
  long unsigned int D.29081;
  long unsigned int D.29082;
  void * * D.29083;
  struct GPtrArray * D.29084;
  unsigned int i.71;
  unsigned int D.29086;
  struct MonoGenericContext * D.29087;
  int mono_use_llvm.72;
  _Bool D.29092;
  long int D.29093;
  long int D.29094;
  struct MonoJumpInfoImtTramp * D.29097;
  int D.29098;
  struct MonoMethod * D.29099;
  unsigned int mono_jit_tls_id.73;
  long unsigned int D.29101;
  const void * D.29102;
  long int D.29103;
  <unnamed type> D.29104;
  long int D.29105;
  unsigned char * ip;
  const void * target;

  D.28872 = patch_info->ip.i;
  D.28873 = (sizetype) D.28872;
  ip = code + D.28873;
  target = 0B;
  D.28874 = patch_info->type;
  switch (D.28874) <default: <D.25999>, case 0: <D.25901>, case 1: <D.25903>, case 2: <D.25904>, case 3: <D.25912>, case 4: <D.25911>, case 5: <D.25906>, case 6: <D.25923>, case 7: <D.25907>, case 8: <D.25917>, case 10: <D.25944>, case 11: <D.25924>, case 12: <D.25925>, case 13: <D.25926>, case 14: <D.25930>, case 15: <D.25931>, case 16: <D.25934>, case 17: <D.25945>, case 18: <D.25949>, case 19: <D.25946>, case 20: <D.25942>, case 21: <D.25943>, case 22: <D.25905>, case 23: <D.25928>, case 24: <D.25929>, case 25: <D.25961>, case 26: <D.25962>, case 27: <D.25963>, case 28: <D.25952>, case 29: <D.25939>, case 30: <D.25933>, case 31: <D.25953>, case 32: <D.25909>, case 33: <D.25958>, case 34: <D.25959>, case 35: <D.25965>, case 36: <D.25986>, case 37: <D.25987>, case 38: <D.25988>, case 40: <D.25989>, case 41: <D.25990>, case 42: <D.25991>, case 43: <D.25994>, case 44: <D.25927>, case 47: <D.25995>, case 48: <D.25996>, case 49: <D.25998>, case 50: <D.25913>, case 51: <D.25964>>
  <D.25901>:
  D.28875 = patch_info->data.bb;
  D.28876 = D.28875->native_offset;
  D.28877 = (sizetype) D.28876;
  target = code + D.28877;
  goto <D.25902>;
  <D.25903>:
  target = patch_info->data.target;
  goto <D.25902>;
  <D.25904>:
  D.28878 = patch_info->data.inst;
  D.28879 = D.28878->data.op[0].const_val;
  D.28880 = (sizetype) D.28879;
  target = code + D.28880;
  goto <D.25902>;
  <D.25905>:
  target = ip;
  goto <D.25902>;
  <D.25906>:
  D.28881 = patch_info->data.offset;
  D.28882 = (sizetype) D.28881;
  target = code + D.28882;
  goto <D.25902>;
  <D.25907>:
  {
    struct MonoJitICallInfo * mi;

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

    D.28883 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.28883);
    if (mi == 0B) goto <D.28886>; else goto <D.28887>;
    <D.28886>:
    D.28883 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.28883);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.28887>:
    target = mi->func;
    goto <D.25902>;
  }
  <D.25911>:
  D.28888 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.28888, 0);
  goto <D.25902>;
  <D.25912>:
  D.28888 = patch_info->data.method;
  if (D.28888 == method) goto <D.28889>; else goto <D.28890>;
  <D.28889>:
  target = code;
  goto <D.28891>;
  <D.28890>:
  D.28888 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.28888);
  <D.28891>:
  goto <D.25902>;
  <D.25913>:
  {
    void * code_slot;

    {
      int ret;

      D.28892 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28892);
      if (ret != 0) goto <D.28893>; else goto <D.28894>;
      <D.28893>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28894>:
      D.28895 = ret != 0;
      D.28896 = (long int) D.28895;
      D.28897 = __builtin_expect (D.28896, 0);
      if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
      <D.28898>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.28899>:
    }
    D.28900 = domain->runtime_info;
    D.28901 = MEM[(struct MonoJitDomainInfo *)D.28900].method_code_hash;
    if (D.28901 == 0B) goto <D.28902>; else goto <D.28903>;
    <D.28902>:
    D.28900 = domain->runtime_info;
    D.28904 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.28900].method_code_hash = D.28904;
    <D.28903>:
    D.28888 = patch_info->data.method;
    D.28900 = domain->runtime_info;
    D.28901 = MEM[(struct MonoJitDomainInfo *)D.28900].method_code_hash;
    code_slot = monoeg_g_hash_table_lookup (D.28901, D.28888);
    if (code_slot == 0B) goto <D.28905>; else goto <D.28906>;
    <D.28905>:
    code_slot = mono_domain_alloc0 (domain, 8);
    D.28888 = patch_info->data.method;
    D.28900 = domain->runtime_info;
    D.28901 = MEM[(struct MonoJitDomainInfo *)D.28900].method_code_hash;
    monoeg_g_hash_table_insert_replace (D.28901, D.28888, code_slot, 0);
    <D.28906>:
    {
      int ret;

      D.28892 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28892);
      if (ret != 0) goto <D.28907>; else goto <D.28908>;
      <D.28907>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28908>:
      D.28909 = ret != 0;
      D.28910 = (long int) D.28909;
      D.28911 = __builtin_expect (D.28910, 0);
      if (D.28911 != 0) goto <D.28912>; else goto <D.28913>;
      <D.28912>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.28913>:
    }
    target = code_slot;
    goto <D.25902>;
  }
  <D.25917>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.28916>; else goto <D.28914>;
    <D.28916>:
    D.28917 = BIT_FIELD_REF <*method, 8, 264>;
    D.28918 = D.28917 & 2;
    if (D.28918 != 0) goto <D.28919>; else goto <D.28914>;
    <D.28919>:
    D.28920 = patch_info->data.table;
    D.28921 = D.28920->table_size;
    D.28922 = (unsigned int) D.28921;
    D.28923 = D.28922 * 8;
    D.28924 = (int) D.28923;
    D.28925 = mono_dynamic_code_hash_lookup (domain, method);
    D.28926 = D.28925->code_mp;
    jump_table = mono_code_manager_reserve (D.28926, D.28924);
    goto <D.28915>;
    <D.28914>:
    mono_aot_only.63 = mono_aot_only;
    if (mono_aot_only.63 != 0) goto <D.28928>; else goto <D.28929>;
    <D.28928>:
    D.28920 = patch_info->data.table;
    D.28921 = D.28920->table_size;
    D.28930 = (long unsigned int) D.28921;
    D.28931 = (unsigned int) D.28930;
    D.28932 = D.28931 * 8;
    jump_table = mono_domain_alloc (domain, D.28932);
    goto <D.28933>;
    <D.28929>:
    D.28920 = patch_info->data.table;
    D.28921 = D.28920->table_size;
    D.28922 = (unsigned int) D.28921;
    D.28923 = D.28922 * 8;
    D.28924 = (int) D.28923;
    jump_table = mono_domain_code_reserve (domain, D.28924);
    <D.28933>:
    <D.28915>:
    i = 0;
    goto <D.25921>;
    <D.25920>:
    D.28934 = (long unsigned int) i;
    D.28935 = D.28934 * 8;
    D.28936 = jump_table + D.28935;
    D.28920 = patch_info->data.table;
    D.28937 = D.28920->table;
    D.28934 = (long unsigned int) i;
    D.28935 = D.28934 * 8;
    D.28938 = D.28937 + D.28935;
    D.28939 = *D.28938;
    D.28940 = (long int) D.28939;
    D.28941 = (int) D.28940;
    D.28942 = (sizetype) D.28941;
    D.28943 = code + D.28942;
    *D.28936 = D.28943;
    i = i + 1;
    <D.25921>:
    D.28920 = patch_info->data.table;
    D.28921 = D.28920->table_size;
    if (D.28921 > i) goto <D.25920>; else goto <D.25922>;
    <D.25922>:
    target = jump_table;
    goto <D.25902>;
  }
  <D.25923>:
  <D.25924>:
  <D.25925>:
  <D.25926>:
  <D.25927>:
  target = patch_info->data.target;
  goto <D.25902>;
  <D.25928>:
  D.28944 = patch_info->data.klass;
  mono_class_init (D.28944);
  D.28944 = patch_info->data.klass;
  D.28945 = D.28944->interface_id;
  D.28946 = (long int) D.28945;
  target = (const void *) D.28946;
  goto <D.25902>;
  <D.25929>:
  D.28944 = patch_info->data.klass;
  mono_class_init (D.28944);
  D.28944 = patch_info->data.klass;
  D.28945 = D.28944->interface_id;
  D.28947 = (int) D.28945;
  D.28948 = ~D.28947;
  D.28949 = D.28948 * 8;
  D.28950 = (long int) D.28949;
  target = (const void *) D.28950;
  goto <D.25902>;
  <D.25930>:
  D.28944 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.28944);
  D.28951 = target == 0B;
  D.28952 = (long int) D.28951;
  D.28953 = __builtin_expect (D.28952, 0);
  if (D.28953 != 0) goto <D.28954>; else goto <D.28955>;
  <D.28954>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.28955>:
  goto <D.25902>;
  <D.25931>:
  {
    struct MonoVTable * vtable;

    D.28944 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.28944);
    D.28956 = vtable == 0B;
    D.28957 = (long int) D.28956;
    D.28958 = __builtin_expect (D.28957, 0);
    if (D.28958 != 0) goto <D.28959>; else goto <D.28960>;
    <D.28959>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.28960>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.25902>;
  }
  <D.25933>:
  D.28944 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.28944);
  goto <D.25902>;
  <D.25934>:
  {
    struct MonoVTable * vtable;

    D.28961 = patch_info->data.field;
    D.28962 = D.28961->parent;
    vtable = mono_class_vtable (domain, D.28962);
    D.28961 = patch_info->data.field;
    D.28963 = mono_class_field_is_special_static (D.28961);
    if (D.28963 != 0) goto <D.28964>; else goto <D.28965>;
    <D.28964>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.28892 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.28892);
        if (ret != 0) goto <D.28966>; else goto <D.28967>;
        <D.28966>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28967>:
        D.28968 = ret != 0;
        D.28969 = (long int) D.28968;
        D.28970 = __builtin_expect (D.28969, 0);
        if (D.28970 != 0) goto <D.28971>; else goto <D.28972>;
        <D.28971>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.28972>:
      }
      D.28973 = domain->special_static_fields;
      if (D.28973 != 0B) goto <D.28974>; else goto <D.28975>;
      <D.28974>:
      D.28961 = patch_info->data.field;
      D.28973 = domain->special_static_fields;
      addr = monoeg_g_hash_table_lookup (D.28973, D.28961);
      <D.28975>:
      {
        int ret;

        D.28892 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.28892);
        if (ret != 0) goto <D.28976>; else goto <D.28977>;
        <D.28976>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28977>:
        D.28978 = ret != 0;
        D.28979 = (long int) D.28978;
        D.28980 = __builtin_expect (D.28979, 0);
        if (D.28980 != 0) goto <D.28981>; else goto <D.28982>;
        <D.28981>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.28982>:
      }
      D.28983 = addr == 0B;
      D.28984 = (long int) D.28983;
      D.28985 = __builtin_expect (D.28984, 0);
      if (D.28985 != 0) goto <D.28986>; else goto <D.28987>;
      <D.28986>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.28987>:
      D.28988 = addr;
      return D.28988;
    }
    <D.28965>:
    D.28989 = vtable == 0B;
    D.28990 = (long int) D.28989;
    D.28991 = __builtin_expect (D.28990, 0);
    if (D.28991 != 0) goto <D.28992>; else goto <D.28993>;
    <D.28992>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.28993>:
    D.28996 = BIT_FIELD_REF <*vtable, 8, 344>;
    D.28997 = D.28996 & 2;
    if (D.28997 == 0) goto <D.28998>; else goto <D.28994>;
    <D.28998>:
    D.28999 = vtable->klass;
    D.29000 = D.28999->flags;
    D.29001 = D.29000 & 1048576;
    if (D.29001 == 0) goto <D.29002>; else goto <D.28994>;
    <D.29002>:
    if (method != 0B) goto <D.29003>; else goto <D.28994>;
    <D.29003>:
    D.28999 = vtable->klass;
    D.29004 = mono_class_needs_cctor_run (D.28999, method);
    if (D.29004 != 0) goto <D.29005>; else goto <D.28994>;
    <D.29005>:
    goto <D.28995>;
    <D.28994>:
    if (run_cctors != 0) goto <D.29006>; else goto <D.29007>;
    <D.29006>:
    mono_runtime_class_init (vtable);
    <D.29007>:
    <D.28995>:
    D.29008 = mono_vtable_get_static_field_data (vtable);
    D.28961 = patch_info->data.field;
    D.29009 = D.28961->offset;
    D.29010 = (sizetype) D.29009;
    target = D.29008 + D.29010;
    goto <D.25902>;
  }
  <D.25939>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.29011 = patch_info->data.token;
        D.29012 = D.29011->token;
        field_index = D.29012 & 16777215;
        D.29013 = field_index + 4294967295;
        D.29011 = patch_info->data.token;
        D.29014 = D.29011->image;
        mono_metadata_field_info (D.29014, D.29013, 0B, &rva, 0B);
        rva.64 = rva;
        D.29011 = patch_info->data.token;
        D.29014 = D.29011->image;
        target = mono_image_rva_map (D.29014, rva.64);
        goto <D.25902>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.25942>:
  <D.25943>:
  target = patch_info->data.target;
  goto <D.25902>;
  <D.25944>:
  target = patch_info->data.name;
  goto <D.25902>;
  <D.25945>:
  D.29011 = patch_info->data.token;
  D.29012 = D.29011->token;
  D.29016 = D.29012 & 16777215;
  D.29011 = patch_info->data.token;
  D.29014 = D.29011->image;
  target = mono_ldstr (domain, D.29014, D.29016);
  goto <D.25902>;
  <D.25946>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.29011 = patch_info->data.token;
        D.29018 = D.29011->has_context;
        if (D.29018 != 0) goto <D.29019>; else goto <D.29020>;
        <D.29019>:
        D.29011 = patch_info->data.token;
        iftmp.65 = &D.29011->context;
        goto <D.29021>;
        <D.29020>:
        iftmp.65 = 0B;
        <D.29021>:
        D.29011 = patch_info->data.token;
        D.29012 = D.29011->token;
        D.29011 = patch_info->data.token;
        D.29014 = D.29011->image;
        handle = mono_ldtoken (D.29014, D.29012, &handle_class, iftmp.65);
        handle_class.66 = handle_class;
        mono_class_init (handle_class.66);
        D.29023 = mono_class_from_mono_type (handle);
        mono_class_init (D.29023);
        target = mono_type_get_object (domain, handle);
        goto <D.25902>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25949>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.29011 = patch_info->data.token;
        D.29018 = D.29011->has_context;
        if (D.29018 != 0) goto <D.29025>; else goto <D.29026>;
        <D.29025>:
        D.29011 = patch_info->data.token;
        iftmp.67 = &D.29011->context;
        goto <D.29027>;
        <D.29026>:
        iftmp.67 = 0B;
        <D.29027>:
        D.29011 = patch_info->data.token;
        D.29012 = D.29011->token;
        D.29011 = patch_info->data.token;
        D.29014 = D.29011->image;
        handle = mono_ldtoken (D.29014, D.29012, &handle_class, iftmp.67);
        handle_class.68 = handle_class;
        mono_class_init (handle_class.68);
        target = handle;
        goto <D.25902>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.25952>:
  D.29011 = patch_info->data.token;
  D.29012 = D.29011->token;
  D.29011 = patch_info->data.token;
  D.29014 = D.29011->image;
  D.29029 = mono_metadata_blob_heap (D.29014, D.29012);
  target = D.29029 + 2;
  goto <D.25902>;
  <D.25953>:
  D.28888 = patch_info->data.method;
  D.29030 = D.28888->flags;
  D.29031 = (int) D.29030;
  D.29032 = D.29031 & 8192;
  if (D.29032 != 0) goto <D.29033>; else goto <D.29034>;
  <D.29033>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.29035>; else goto <D.29036>;
        <D.29035>:
        D.28888 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.28888, &exc_class, &exc_arg);
        if (target == 0B) goto <D.29037>; else goto <D.29038>;
        <D.29037>:
        mono_aot_only.63 = mono_aot_only;
        if (mono_aot_only.63 != 0) goto <D.29039>; else goto <D.29040>;
        <D.29039>:
        exc_arg.69 = exc_arg;
        exc_class.70 = exc_class;
        D.29043 = mono_defaults.corlib;
        D.29044 = mono_exception_from_name_msg (D.29043, "System", exc_class.70, exc_arg.69);
        mono_raise_exception (D.29044);
        <D.29040>:
        D.28888 = patch_info->data.method;
        D.29045 = mono_method_full_name (D.28888, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.29045);
        <D.25956>:
        goto <D.25956>;
        <D.29038>:
        goto <D.29046>;
        <D.29036>:
        target = 0B;
        <D.29046>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.29047>;
  <D.29034>:
  D.28888 = patch_info->data.method;
  target = mono_lookup_internal_call (D.28888);
  D.28951 = target == 0B;
  D.29048 = run_cctors != 0;
  D.29049 = D.28951 & D.29048;
  if (D.29049 != 0) goto <D.29050>; else goto <D.29051>;
  <D.29050>:
  D.28888 = patch_info->data.method;
  D.29052 = mono_method_full_name (D.28888, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.29052);
  <D.25957>:
  goto <D.25957>;
  <D.29051>:
  <D.29047>:
  goto <D.25902>;
  <D.25958>:
  target = mono_thread_interruption_request_flag ();
  goto <D.25902>;
  <D.25959>:
  {
    struct MonoVTable * vtable;

    D.28888 = patch_info->data.method;
    D.29053 = D.28888->klass;
    vtable = mono_class_vtable (domain, D.29053);
    D.29054 = vtable == 0B;
    D.29055 = (long int) D.29054;
    D.29056 = __builtin_expect (D.29055, 0);
    if (D.29056 != 0) goto <D.29057>; else goto <D.29058>;
    <D.29057>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.29058>:
    D.28888 = patch_info->data.method;
    D.29059 = mini_method_get_context (D.28888);
    D.29060 = D.29059->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.29060);
    goto <D.25902>;
  }
  <D.25961>:
  <D.25962>:
  <D.25963>:
  <D.25964>:
  goto <D.25902>;
  <D.25965>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.29061 = entry->data;
    D.29062 = D.29061->type;
    switch (D.29062) <default: <D.25985>, case 3: <D.25970>, case 6: <D.25971>, case 11: <D.25968>, case 13: <D.25972>, case 44: <D.25973>, case 45: <D.25974>, case 46: <D.25976>>
    <D.25968>:
    D.29063 = entry->method;
    D.29064 = mono_method_get_context (D.29063);
    D.29065 = entry->info_type;
    D.29061 = entry->data;
    D.29066 = D.29061->data.klass;
    D.29067 = &D.29066->byval_arg;
    D.29068 = entry->in_mrgctx;
    D.29063 = entry->method;
    slot = mono_method_lookup_or_register_info (D.29063, D.29068, D.29067, D.29065, D.29064);
    goto <D.25969>;
    <D.25970>:
    <D.25971>:
    D.29063 = entry->method;
    D.29069 = mono_method_get_context (D.29063);
    D.29065 = entry->info_type;
    D.29061 = entry->data;
    D.29070 = D.29061->data.method;
    D.29068 = entry->in_mrgctx;
    D.29063 = entry->method;
    slot = mono_method_lookup_or_register_info (D.29063, D.29068, D.29070, D.29065, D.29069);
    goto <D.25969>;
    <D.25972>:
    D.29063 = entry->method;
    D.29071 = mono_method_get_context (D.29063);
    D.29065 = entry->info_type;
    D.29061 = entry->data;
    D.29072 = D.29061->data.field;
    D.29068 = entry->in_mrgctx;
    D.29063 = entry->method;
    slot = mono_method_lookup_or_register_info (D.29063, D.29068, D.29072, D.29065, D.29071);
    goto <D.25969>;
    <D.25973>:
    D.29063 = entry->method;
    D.29073 = mono_method_get_context (D.29063);
    D.29065 = entry->info_type;
    D.29061 = entry->data;
    D.29074 = D.29061->data.sig;
    D.29068 = entry->in_mrgctx;
    D.29063 = entry->method;
    slot = mono_method_lookup_or_register_info (D.29063, D.29068, D.29074, D.29065, D.29073);
    goto <D.25969>;
    <D.25974>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (16);
      D.29061 = entry->data;
      D.29075 = D.29061->data.gsharedvt;
      memcpy (call_info, D.29075, 16);
      D.29063 = entry->method;
      D.29076 = mono_method_get_context (D.29063);
      D.29065 = entry->info_type;
      D.29068 = entry->in_mrgctx;
      D.29063 = entry->method;
      slot = mono_method_lookup_or_register_info (D.29063, D.29068, call_info, D.29065, D.29076);
      goto <D.25969>;
    }
    <D.25976>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.29061 = entry->data;
      oinfo = D.29061->data.gsharedvt_method;
      info = monoeg_malloc0 (16);
      D.29077 = oinfo->method;
      info->method = D.29077;
      D.29078 = monoeg_g_ptr_array_new ();
      info->entries = D.29078;
      i = 0;
      goto <D.25983>;
      <D.25982>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.29079 = oinfo->entries;
        D.29080 = D.29079->pdata;
        D.29081 = (long unsigned int) i;
        D.29082 = D.29081 * 8;
        D.29083 = D.29080 + D.29082;
        otemplate = *D.29083;
        template = monoeg_malloc0 (24);
        memcpy (template, otemplate, 24);
        D.29084 = info->entries;
        monoeg_g_ptr_array_add (D.29084, template);
      }
      i = i + 1;
      <D.25983>:
      i.71 = (unsigned int) i;
      D.29079 = oinfo->entries;
      D.29086 = D.29079->len;
      if (i.71 < D.29086) goto <D.25982>; else goto <D.25984>;
      <D.25984>:
      D.29063 = entry->method;
      D.29087 = mono_method_get_context (D.29063);
      D.29065 = entry->info_type;
      D.29068 = entry->in_mrgctx;
      D.29063 = entry->method;
      slot = mono_method_lookup_or_register_info (D.29063, D.29068, info, D.29065, D.29087);
      goto <D.25969>;
    }
    <D.25985>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.25969>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.25902>;
  }
  <D.25986>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.25902>;
  <D.25987>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.25902>;
  <D.25988>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.25902>;
  <D.25989>:
  if (run_cctors == 0) goto <D.29088>; else goto <D.29089>;
  <D.29088>:
  target = 0B;
  goto <D.29090>;
  <D.29089>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.29090>:
  goto <D.25902>;
  <D.25990>:
  mono_use_llvm.72 = mono_use_llvm;
  D.29092 = mono_use_llvm.72 == 0;
  D.29093 = (long int) D.29092;
  D.29094 = __builtin_expect (D.29093, 0);
  if (D.29094 != 0) goto <D.29095>; else goto <D.29096>;
  <D.29095>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3606, "mono_use_llvm");
  <D.29096>:
  D.29097 = patch_info->data.imt_tramp;
  D.29098 = D.29097->vt_offset;
  D.29097 = patch_info->data.imt_tramp;
  D.29099 = D.29097->method;
  target = mono_create_llvm_imt_trampoline (domain, D.29099, D.29098);
  goto <D.25902>;
  <D.25991>:
  {
    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.25902>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.25994>:
  target = mono_domain_alloc0 (domain, 8);
  goto <D.25902>;
  <D.25995>:
  mono_jit_tls_id.73 = mono_jit_tls_id;
  D.29101 = (long unsigned int) mono_jit_tls_id.73;
  target = (const void *) D.29101;
  goto <D.25902>;
  <D.25996>:
  {
    int offset;

    D.29102 = patch_info->data.target;
    D.29103 = (long int) D.29102;
    D.29104 = (<unnamed type>) D.29103;
    offset = mini_get_tls_offset (D.29104);
    offset = mono_arch_translate_tls_offset (offset);
    D.29105 = (long int) offset;
    target = (const void *) D.29105;
    goto <D.25902>;
  }
  <D.25998>:
  target = 0B;
  goto <D.25902>;
  <D.25999>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.25902>:
  D.28988 = target;
  return D.28988;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.29112;
  struct GHashTable * D.29113;
  struct MonoJitDynamicMethodInfo * D.29117;
  struct MonoJitDynamicMethodInfo * res;

  D.29112 = domain->runtime_info;
  D.29113 = MEM[(struct MonoJitDomainInfo *)D.29112].dynamic_code_hash;
  if (D.29113 != 0B) goto <D.29114>; else goto <D.29115>;
  <D.29114>:
  D.29112 = domain->runtime_info;
  D.29113 = MEM[(struct MonoJitDomainInfo *)D.29112].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.29113, method);
  goto <D.29116>;
  <D.29115>:
  res = 0B;
  <D.29116>:
  D.29117 = res;
  return D.29117;
}


mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  long int D.29119;
  struct GPtrArray * D.29120;
  struct GSList * D.29123;
  struct MonoMemPool * D.29124;
  struct GSList * D.29125;

  D.29119 = (long int) native_offset;
  ins->data.op[0].const_val = D.29119;
  D.29120 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.29120, ins);
  if (bb != 0B) goto <D.29121>; else goto <D.29122>;
  <D.29121>:
  D.29123 = bb->seq_points;
  D.29124 = cfg->mempool;
  D.29125 = g_slist_prepend_mempool (D.29124, D.29123, ins);
  bb->seq_points = D.29125;
  bb->last_seq_point = ins;
  <D.29122>:
}


mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.29126;
  _Bool D.29129;
  long int D.29130;
  long int D.29131;
  struct MonoInst * * D.29134;
  struct MonoInst * D.29135;
  struct GSList * D.29138;
  struct GSList * D.29139;
  struct MonoInst * D.29141;
  struct GSList * D.29144;
  struct GSList * D.29145;
  struct MonoDwarfLocListEntry * entry;

  D.29126 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.29126, 20);
  if (is_reg != 0) goto <D.29127>; else goto <D.29128>;
  <D.29127>:
  D.29129 = offset != 0;
  D.29130 = (long int) D.29129;
  D.29131 = __builtin_expect (D.29130, 0);
  if (D.29131 != 0) goto <D.29132>; else goto <D.29133>;
  <D.29132>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.29133>:
  <D.29128>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.29134 = cfg->args;
  D.29135 = *D.29134;
  if (D.29135 == var) goto <D.29136>; else goto <D.29137>;
  <D.29136>:
  D.29138 = cfg->this_loclist;
  D.29126 = cfg->mempool;
  D.29139 = g_slist_append_mempool (D.29126, D.29138, entry);
  cfg->this_loclist = D.29139;
  goto <D.29140>;
  <D.29137>:
  D.29141 = cfg->rgctx_var;
  if (D.29141 == var) goto <D.29142>; else goto <D.29143>;
  <D.29142>:
  D.29144 = cfg->rgctx_loclist;
  D.29126 = cfg->mempool;
  D.29145 = g_slist_append_mempool (D.29126, D.29144, entry);
  cfg->rgctx_loclist = D.29145;
  <D.29143>:
  <D.29140>:
}


mono_print_code (struct MonoCompile * cfg, const char * msg)
{
  struct MonoBasicBlock * bb;

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


mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.74;
  unsigned int D.29150;
  unsigned int D.29151;
  unsigned char D.29154;
  unsigned char D.29155;
  unsigned int D.29160;
  unsigned int D.29161;
  unsigned int D.29164;
  int D.29165;
  struct MonoMethod * D.29166;
  struct MonoProfileCoverageInfo * D.29167;
  unsigned int D.29168;
  long int code.75;
  unsigned char * D.29172;
  long int D.29173;
  long int D.29174;
  unsigned int D.29175;
  unsigned int D.29176;
  int D.29177;
  int D.29178;
  unsigned int D.29179;
  unsigned int D.29180;
  int D.29181;
  struct MonoBasicBlock * D.29182;
  sizetype D.29187;
  unsigned int D.29188;
  _Bool D.29189;
  long int D.29190;
  long int D.29191;
  unsigned int max_epilog_size.76;
  unsigned int D.29195;
  unsigned char D.29196;
  unsigned char D.29197;
  void * D.29200;
  struct MonoJitDynamicMethodInfo * D.29201;
  struct MonoCodeManager * D.29202;
  struct MonoDomain * D.29203;
  union mono_mutex_t * D.29204;
  _Bool D.29207;
  long int D.29208;
  long int D.29209;
  _Bool D.29214;
  long int D.29215;
  long int D.29216;
  unsigned int D.29221;
  int D.29222;
  struct MonoCodeManager * D.29224;
  unsigned int D.29226;
  int D.29227;
  _Bool D.29228;
  long int D.29229;
  long int D.29230;
  long unsigned int D.29233;
  unsigned int D.29234;
  char * D.29237;
  unsigned char * D.29238;
  unsigned char D.29241;
  struct MonoGenericContainer * D.29243;
  struct MonoClass * D.29245;
  struct MonoGenericContainer * D.29246;
  struct MonoGenericClass * D.29248;
  struct MonoGenericSharingContext * D.29249;
  _Bool D.29252;
  long int D.29253;
  long int D.29254;
  <unnamed-unsigned:1> D.29257;
  int D.29258;
  struct MonoCodeManager * iftmp.77;
  struct MonoJumpInfo * D.29263;
  int D.29268;
  int D.29271;
  struct MonoBasicBlock * bb;
  int max_epilog_size;
  guint8 * code;
  struct MonoDomain * code_domain;

  mono_using_xdebug.74 = mono_using_xdebug;
  if (mono_using_xdebug.74 != 0) goto <D.29147>; else goto <D.29148>;
  <D.29147>:
  code_domain = mono_get_root_domain ();
  goto <D.29149>;
  <D.29148>:
  code_domain = cfg->domain;
  <D.29149>:
  bb = cfg->bb_entry;
  goto <D.26135>;
  <D.26134>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.29150 = cfg->opt;
  D.29151 = D.29150 & 1;
  if (D.29151 != 0) goto <D.29152>; else goto <D.29153>;
  <D.29152>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.29153>:
  D.29154 = BIT_FIELD_REF <*cfg, 8, 5608>;
  D.29155 = D.29154 & 16;
  if (D.29155 == 0) goto <D.29156>; else goto <D.29157>;
  <D.29156>:
  mono_local_regalloc (cfg, bb);
  <D.29157>:
  D.29150 = cfg->opt;
  D.29151 = D.29150 & 1;
  if (D.29151 != 0) goto <D.29158>; else goto <D.29159>;
  <D.29158>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.29159>:
  bb = bb->next_bb;
  <D.26135>:
  if (bb != 0B) goto <D.26134>; else goto <D.26136>;
  <D.26136>:
  D.29160 = cfg->prof_options;
  D.29161 = D.29160 & 8192;
  if (D.29161 != 0) goto <D.29162>; else goto <D.29163>;
  <D.29162>:
  D.29164 = cfg->num_bblocks;
  D.29165 = (int) D.29164;
  D.29166 = cfg->method;
  D.29167 = mono_profiler_coverage_alloc (D.29166, D.29165);
  cfg->coverage_info = D.29167;
  <D.29163>:
  code = mono_arch_emit_prolog (cfg);
  D.29160 = cfg->prof_options;
  D.29168 = D.29160 & 4096;
  if (D.29168 != 0) goto <D.29169>; else goto <D.29170>;
  <D.29169>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.29170>:
  code.75 = (long int) code;
  D.29172 = cfg->native_code;
  D.29173 = (long int) D.29172;
  D.29174 = code.75 - D.29173;
  D.29175 = (unsigned int) D.29174;
  cfg->code_len = D.29175;
  D.29176 = cfg->code_len;
  cfg->prolog_end = D.29176;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.26138>;
  <D.26137>:
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  bb->native_offset = D.29177;
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  bb->real_native_offset = D.29177;
  mono_arch_output_basic_block (cfg, bb);
  D.29176 = cfg->code_len;
  D.29178 = bb->native_offset;
  D.29179 = (unsigned int) D.29178;
  D.29180 = D.29176 - D.29179;
  D.29181 = (int) D.29180;
  bb->native_length = D.29181;
  D.29182 = cfg->bb_exit;
  if (D.29182 == bb) goto <D.29183>; else goto <D.29184>;
  <D.29183>:
  D.29176 = cfg->code_len;
  cfg->epilog_begin = D.29176;
  D.29160 = cfg->prof_options;
  D.29168 = D.29160 & 4096;
  if (D.29168 != 0) goto <D.29185>; else goto <D.29186>;
  <D.29185>:
  D.29172 = cfg->native_code;
  D.29176 = cfg->code_len;
  D.29187 = (sizetype) D.29176;
  code = D.29172 + D.29187;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.75 = (long int) code;
  D.29172 = cfg->native_code;
  D.29173 = (long int) D.29172;
  D.29174 = code.75 - D.29173;
  D.29175 = (unsigned int) D.29174;
  cfg->code_len = D.29175;
  D.29176 = cfg->code_len;
  D.29188 = cfg->code_size;
  D.29189 = D.29176 >= D.29188;
  D.29190 = (long int) D.29189;
  D.29191 = __builtin_expect (D.29190, 0);
  if (D.29191 != 0) goto <D.29192>; else goto <D.29193>;
  <D.29192>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.29193>:
  <D.29186>:
  mono_arch_emit_epilog (cfg);
  <D.29184>:
  bb = bb->next_bb;
  <D.26138>:
  if (bb != 0B) goto <D.26137>; else goto <D.26139>;
  <D.26139>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.29176 = cfg->code_len;
  max_epilog_size.76 = (unsigned int) max_epilog_size;
  D.29195 = D.29176 + max_epilog_size.76;
  cfg->code_size = D.29195;
  D.29166 = cfg->method;
  D.29196 = BIT_FIELD_REF <*D.29166, 8, 264>;
  D.29197 = D.29196 & 2;
  if (D.29197 != 0) goto <D.29198>; else goto <D.29199>;
  <D.29198>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29200 = monoeg_malloc0 (16);
    cfg->dynamic_info = D.29200;
    D.29201 = cfg->dynamic_info;
    D.29202 = mono_code_manager_new_dynamic ();
    D.29201->code_mp = D.29202;
    {
      int ret;

      D.29203 = cfg->domain;
      D.29204 = &D.29203->lock.mutex;
      ret = pthread_mutex_lock (D.29204);
      if (ret != 0) goto <D.29205>; else goto <D.29206>;
      <D.29205>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29206>:
      D.29207 = ret != 0;
      D.29208 = (long int) D.29207;
      D.29209 = __builtin_expect (D.29208, 0);
      if (D.29209 != 0) goto <D.29210>; else goto <D.29211>;
      <D.29210>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.29211>:
    }
    D.29201 = cfg->dynamic_info;
    D.29166 = cfg->method;
    D.29203 = cfg->domain;
    mono_dynamic_code_hash_insert (D.29203, D.29166, D.29201);
    {
      int ret;

      D.29203 = cfg->domain;
      D.29204 = &D.29203->lock.mutex;
      ret = pthread_mutex_unlock (D.29204);
      if (ret != 0) goto <D.29212>; else goto <D.29213>;
      <D.29212>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29213>:
      D.29214 = ret != 0;
      D.29215 = (long int) D.29214;
      D.29216 = __builtin_expect (D.29215, 0);
      if (D.29216 != 0) goto <D.29217>; else goto <D.29218>;
      <D.29217>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.29218>:
    }
    mono_using_xdebug.74 = mono_using_xdebug;
    if (mono_using_xdebug.74 != 0) goto <D.29219>; else goto <D.29220>;
    <D.29219>:
    D.29188 = cfg->code_size;
    D.29221 = D.29188 + unwindlen;
    D.29222 = (int) D.29221;
    code = mono_domain_code_reserve (code_domain, D.29222);
    goto <D.29223>;
    <D.29220>:
    D.29188 = cfg->code_size;
    D.29221 = D.29188 + unwindlen;
    D.29222 = (int) D.29221;
    D.29201 = cfg->dynamic_info;
    D.29224 = D.29201->code_mp;
    code = mono_code_manager_reserve (D.29224, D.29222);
    <D.29223>:
  }
  goto <D.29225>;
  <D.29199>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29188 = cfg->code_size;
    D.29226 = D.29188 + unwindlen;
    D.29227 = (int) D.29226;
    code = mono_domain_code_reserve (code_domain, D.29227);
  }
  <D.29225>:
  D.29228 = code == 0B;
  D.29229 = (long int) D.29228;
  D.29230 = __builtin_expect (D.29229, 0);
  if (D.29230 != 0) goto <D.29231>; else goto <D.29232>;
  <D.29231>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.29232>:
  D.29176 = cfg->code_len;
  D.29233 = (long unsigned int) D.29176;
  D.29172 = cfg->native_code;
  memcpy (code, D.29172, D.29233);
  D.29172 = cfg->native_code;
  monoeg_g_free (D.29172);
  cfg->native_code = code;
  D.29172 = cfg->native_code;
  D.29176 = cfg->code_len;
  D.29187 = (sizetype) D.29176;
  code = D.29172 + D.29187;
  mono_postprocess_patches (cfg);
  D.29234 = cfg->verbose_level;
  if (D.29234 != 0) goto <D.29235>; else goto <D.29236>;
  <D.29235>:
  {
    char * nm;

    D.29166 = cfg->method;
    nm = mono_method_full_name (D.29166, 1);
    D.29203 = cfg->domain;
    D.29237 = D.29203->friendly_name;
    D.29176 = cfg->code_len;
    D.29172 = cfg->native_code;
    D.29176 = cfg->code_len;
    D.29187 = (sizetype) D.29176;
    D.29238 = D.29172 + D.29187;
    D.29172 = cfg->native_code;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.29172, D.29238, D.29176, D.29237);
    monoeg_g_free (nm);
  }
  <D.29236>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.29166 = cfg->method;
    D.29196 = BIT_FIELD_REF <*D.29166, 8, 264>;
    D.29241 = D.29196 & 16;
    if (D.29241 != 0) goto <D.29239>; else goto <D.29242>;
    <D.29242>:
    D.29166 = cfg->method;
    D.29243 = mono_method_get_generic_container (D.29166);
    if (D.29243 != 0B) goto <D.29239>; else goto <D.29244>;
    <D.29244>:
    D.29166 = cfg->method;
    D.29245 = D.29166->klass;
    D.29246 = D.29245->generic_container;
    if (D.29246 != 0B) goto <D.29239>; else goto <D.29247>;
    <D.29247>:
    D.29166 = cfg->method;
    D.29245 = D.29166->klass;
    D.29248 = D.29245->generic_class;
    if (D.29248 != 0B) goto <D.29239>; else goto <D.29240>;
    <D.29239>:
    is_generic = 1;
    <D.29240>:
    D.29249 = cfg->generic_sharing_context;
    if (D.29249 != 0B) goto <D.29250>; else goto <D.29251>;
    <D.29250>:
    D.29252 = is_generic == 0;
    D.29253 = (long int) D.29252;
    D.29254 = __builtin_expect (D.29253, 0);
    if (D.29254 != 0) goto <D.29255>; else goto <D.29256>;
    <D.29255>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.29256>:
    <D.29251>:
  }
  D.29257 = cfg->run_cctors;
  D.29258 = (int) D.29257;
  D.29201 = cfg->dynamic_info;
  if (D.29201 != 0B) goto <D.29260>; else goto <D.29261>;
  <D.29260>:
  D.29201 = cfg->dynamic_info;
  iftmp.77 = D.29201->code_mp;
  goto <D.29262>;
  <D.29261>:
  iftmp.77 = 0B;
  <D.29262>:
  D.29263 = cfg->patch_info;
  D.29172 = cfg->native_code;
  D.29203 = cfg->domain;
  D.29166 = cfg->method;
  mono_arch_patch_code (D.29166, D.29203, D.29172, D.29263, iftmp.77, D.29258);
  D.29166 = cfg->method;
  D.29196 = BIT_FIELD_REF <*D.29166, 8, 264>;
  D.29197 = D.29196 & 2;
  if (D.29197 != 0) goto <D.29264>; else goto <D.29265>;
  <D.29264>:
  mono_using_xdebug.74 = mono_using_xdebug;
  if (mono_using_xdebug.74 != 0) goto <D.29266>; else goto <D.29267>;
  <D.29266>:
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  D.29188 = cfg->code_size;
  D.29268 = (int) D.29188;
  D.29172 = cfg->native_code;
  mono_domain_code_commit (code_domain, D.29172, D.29268, D.29177);
  goto <D.29269>;
  <D.29267>:
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  D.29188 = cfg->code_size;
  D.29268 = (int) D.29188;
  D.29172 = cfg->native_code;
  D.29201 = cfg->dynamic_info;
  D.29224 = D.29201->code_mp;
  mono_code_manager_commit (D.29224, D.29172, D.29268, D.29177);
  <D.29269>:
  goto <D.29270>;
  <D.29265>:
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  D.29188 = cfg->code_size;
  D.29268 = (int) D.29188;
  D.29172 = cfg->native_code;
  mono_domain_code_commit (code_domain, D.29172, D.29268, D.29177);
  <D.29270>:
  D.29166 = cfg->method;
  D.29176 = cfg->code_len;
  D.29177 = (int) D.29176;
  D.29172 = cfg->native_code;
  mono_profiler_code_buffer_new (D.29172, D.29177, 1, D.29166);
  D.29176 = cfg->code_len;
  D.29271 = (int) D.29176;
  D.29172 = cfg->native_code;
  mono_arch_flush_icache (D.29172, D.29271);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.29272;
  struct GHashTable * D.29273;
  struct GHashTable * D.29276;

  D.29272 = domain->runtime_info;
  D.29273 = MEM[(struct MonoJitDomainInfo *)D.29272].dynamic_code_hash;
  if (D.29273 == 0B) goto <D.29274>; else goto <D.29275>;
  <D.29274>:
  D.29272 = domain->runtime_info;
  D.29276 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.29272].dynamic_code_hash = D.29276;
  <D.29275>:
  D.29272 = domain->runtime_info;
  D.29273 = MEM[(struct MonoJitDomainInfo *)D.29272].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.29273, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.29277;
  const void * D.29278;
  const char * D.29281;
  char * D.29282;
  char * D.29285;
  struct GHashTable * D.29290;
  <unnamed type> D.29295;
  const void * D.29296;
  struct MonoMethod * D.29297;
  unsigned char D.29298;
  unsigned char D.29299;
  struct MonoJumpInfoBBTable * D.29302;
  int D.29303;
  unsigned int D.29304;
  unsigned int D.29305;
  int D.29306;
  struct MonoJitDynamicMethodInfo * D.29307;
  struct MonoCodeManager * D.29308;
  struct MonoDomain * D.29310;
  struct MonoBasicBlock * * D.29311;
  long unsigned int D.29312;
  long unsigned int D.29313;
  struct MonoBasicBlock * * D.29314;
  struct MonoBasicBlock * D.29315;
  int D.29318;
  _Bool D.29319;
  long int D.29320;
  long int D.29321;
  void * * D.29324;
  long int D.29325;
  void * D.29326;
  unsigned char * D.29328;
  int D.29329;
  sizetype D.29330;
  union mono_mutex_t * D.29331;
  _Bool D.29334;
  long int D.29335;
  long int D.29336;
  struct MonoMethod * D.29339;
  void * D.29340;
  struct GHashTable * D.29341;
  struct GSList * D.29344;
  struct GSList * D.29345;
  _Bool D.29348;
  long int D.29349;
  long int D.29350;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.26062>;
  <D.26061>:
  D.29277 = patch_info->type;
  switch (D.29277) <default: <D.26060>, case 1: <D.26045>, case 4: <D.26054>, case 8: <D.26049>>
  <D.26045>:
  {
    struct MonoJitICallInfo * info;

    D.29278 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.29278);
    if (info != 0B) goto <D.29279>; else goto <D.29280>;
    <D.29279>:
    D.29281 = info->name;
    D.29282 = strstr (D.29281, "ves_array_new_va_");
    if (D.29282 == 0B) goto <D.29283>; else goto <D.29284>;
    <D.29283>:
    D.29281 = info->name;
    D.29285 = strstr (D.29281, "ves_array_element_address_");
    if (D.29285 == 0B) goto <D.29286>; else goto <D.29287>;
    <D.29286>:
    patch_info->type = 7;
    D.29281 = info->name;
    patch_info->data.name = D.29281;
    <D.29287>:
    <D.29284>:
    <D.29280>:
    D.29277 = patch_info->type;
    if (D.29277 == 1) goto <D.29288>; else goto <D.29289>;
    <D.29288>:
    D.29290 = cfg->abs_patches;
    if (D.29290 != 0B) goto <D.29291>; else goto <D.29292>;
    <D.29291>:
    {
      struct MonoJumpInfo * abs_ji;

      D.29278 = patch_info->data.target;
      D.29290 = cfg->abs_patches;
      abs_ji = monoeg_g_hash_table_lookup (D.29290, D.29278);
      if (abs_ji != 0B) goto <D.29293>; else goto <D.29294>;
      <D.29293>:
      D.29295 = abs_ji->type;
      patch_info->type = D.29295;
      D.29296 = abs_ji->data.target;
      patch_info->data.target = D.29296;
      <D.29294>:
    }
    <D.29292>:
    <D.29289>:
    goto <D.26048>;
  }
  <D.26049>:
  {
    void * * table;

    D.29297 = cfg->method;
    D.29298 = BIT_FIELD_REF <*D.29297, 8, 264>;
    D.29299 = D.29298 & 2;
    if (D.29299 != 0) goto <D.29300>; else goto <D.29301>;
    <D.29300>:
    D.29302 = patch_info->data.table;
    D.29303 = D.29302->table_size;
    D.29304 = (unsigned int) D.29303;
    D.29305 = D.29304 * 8;
    D.29306 = (int) D.29305;
    D.29307 = cfg->dynamic_info;
    D.29308 = D.29307->code_mp;
    table = mono_code_manager_reserve (D.29308, D.29306);
    goto <D.29309>;
    <D.29301>:
    D.29302 = patch_info->data.table;
    D.29303 = D.29302->table_size;
    D.29304 = (unsigned int) D.29303;
    D.29305 = D.29304 * 8;
    D.29306 = (int) D.29305;
    D.29310 = cfg->domain;
    table = mono_domain_code_reserve (D.29310, D.29306);
    <D.29309>:
    i = 0;
    goto <D.26052>;
    <D.26051>:
    D.29302 = patch_info->data.table;
    D.29311 = D.29302->table;
    D.29312 = (long unsigned int) i;
    D.29313 = D.29312 * 8;
    D.29314 = D.29311 + D.29313;
    D.29315 = *D.29314;
    if (D.29315 != 0B) goto <D.29316>; else goto <D.29317>;
    <D.29316>:
    D.29302 = patch_info->data.table;
    D.29311 = D.29302->table;
    D.29312 = (long unsigned int) i;
    D.29313 = D.29312 * 8;
    D.29314 = D.29311 + D.29313;
    D.29315 = *D.29314;
    D.29318 = D.29315->native_offset;
    D.29319 = D.29318 == 0;
    D.29320 = (long int) D.29319;
    D.29321 = __builtin_expect (D.29320, 0);
    if (D.29321 != 0) goto <D.29322>; else goto <D.29323>;
    <D.29322>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.29323>:
    D.29312 = (long unsigned int) i;
    D.29313 = D.29312 * 8;
    D.29324 = table + D.29313;
    D.29302 = patch_info->data.table;
    D.29311 = D.29302->table;
    D.29312 = (long unsigned int) i;
    D.29313 = D.29312 * 8;
    D.29314 = D.29311 + D.29313;
    D.29315 = *D.29314;
    D.29318 = D.29315->native_offset;
    D.29325 = (long int) D.29318;
    D.29326 = (void *) D.29325;
    *D.29324 = D.29326;
    goto <D.29327>;
    <D.29317>:
    D.29312 = (long unsigned int) i;
    D.29313 = D.29312 * 8;
    D.29324 = table + D.29313;
    *D.29324 = 0B;
    <D.29327>:
    i = i + 1;
    <D.26052>:
    D.29302 = patch_info->data.table;
    D.29303 = D.29302->table_size;
    if (D.29303 > i) goto <D.26051>; else goto <D.26053>;
    <D.26053>:
    D.29302 = patch_info->data.table;
    D.29302->table = table;
    goto <D.26048>;
  }
  <D.26054>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.29328 = cfg->native_code;
    D.29329 = patch_info->ip.i;
    D.29330 = (sizetype) D.29329;
    ip = D.29328 + D.29330;
    {
      int ret;

      D.29331 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.29331);
      if (ret != 0) goto <D.29332>; else goto <D.29333>;
      <D.29332>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29333>:
      D.29334 = ret != 0;
      D.29335 = (long int) D.29334;
      D.29336 = __builtin_expect (D.29335, 0);
      if (D.29336 != 0) goto <D.29337>; else goto <D.29338>;
      <D.29337>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.29338>:
    }
    D.29339 = patch_info->data.method;
    D.29340 = domain->runtime_info;
    D.29341 = MEM[(struct MonoJitDomainInfo *)D.29340].jump_target_hash;
    jlist = monoeg_g_hash_table_lookup (D.29341, D.29339);
    if (jlist == 0B) goto <D.29342>; else goto <D.29343>;
    <D.29342>:
    jlist = mono_domain_alloc0 (domain, 8);
    D.29339 = patch_info->data.method;
    D.29340 = domain->runtime_info;
    D.29341 = MEM[(struct MonoJitDomainInfo *)D.29340].jump_target_hash;
    monoeg_g_hash_table_insert_replace (D.29341, D.29339, jlist, 0);
    <D.29343>:
    D.29344 = jlist->list;
    D.29345 = monoeg_g_slist_prepend (D.29344, ip);
    jlist->list = D.29345;
    {
      int ret;

      D.29331 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.29331);
      if (ret != 0) goto <D.29346>; else goto <D.29347>;
      <D.29346>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29347>:
      D.29348 = ret != 0;
      D.29349 = (long int) D.29348;
      D.29350 = __builtin_expect (D.29349, 0);
      if (D.29350 != 0) goto <D.29351>; else goto <D.29352>;
      <D.29351>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3842, "ret == 0");
      <D.29352>:
    }
    goto <D.26048>;
  }
  <D.26060>:
  goto <D.26048>;
  <D.26048>:
  patch_info = patch_info->next;
  <D.26062>:
  if (patch_info != 0B) goto <D.26061>; else goto <D.26063>;
  <D.26063>:
}


mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  unsigned char D.29357;
  unsigned char D.29358;
  struct MonoClass * D.29360;
  struct MonoGenericContainer * D.29361;
  unsigned char D.29363;
  unsigned char D.29364;
  unsigned char D.29365;
  struct MonoGenericContainer * D.29368;
  struct MonoClass * D.29370;
  struct MonoGenericContainer * D.29371;
  int D.29377;
  int D.29379;
  int iftmp.78;
  int D.29386;
  struct MonoGenericInst * D.29392;
  struct MonoGenericInst * D.29393;
  struct MonoGenericInst * D.29399;
  struct MonoGenericInst * D.29400;
  struct MonoClass * D.29403;
  unsigned char D.29404;
  unsigned char D.29405;
  _Bool D.29406;
  long int D.29407;
  long int D.29408;
  struct MonoMethod * D.29411;
  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.29357 = BIT_FIELD_REF <*method, 8, 264>;
      D.29358 = D.29357 & 8;
      if (D.29358 != 0) goto <D.29354>; else goto <D.29359>;
      <D.29359>:
      D.29360 = method->klass;
      D.29361 = D.29360->generic_container;
      if (D.29361 != 0B) goto <D.29362>; else goto <D.29355>;
      <D.29362>:
      D.29357 = BIT_FIELD_REF <*method, 8, 264>;
      D.29363 = D.29357 & 16;
      if (D.29363 == 0) goto <D.29354>; else goto <D.29355>;
      <D.29354>:
      declaring_method = method;
      goto <D.29356>;
      <D.29355>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.29356>:
      D.29364 = BIT_FIELD_REF <*declaring_method, 8, 264>;
      D.29365 = D.29364 & 8;
      if (D.29365 != 0) goto <D.29366>; else goto <D.29367>;
      <D.29366>:
      D.29368 = mono_method_get_generic_container (declaring_method);
      shared_context = D.29368->context;
      goto <D.29369>;
      <D.29367>:
      D.29370 = declaring_method->klass;
      D.29371 = D.29370->generic_container;
      shared_context = D.29371->context;
      <D.29369>:
      if (method != declaring_method) goto <D.29375>; else goto <D.29372>;
      <D.29375>:
      D.29357 = BIT_FIELD_REF <*method, 8, 264>;
      D.29363 = D.29357 & 16;
      if (D.29363 != 0) goto <D.29376>; else goto <D.29372>;
      <D.29376>:
      D.29377 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29377 == 0) goto <D.29373>; else goto <D.29372>;
      <D.29372>:
      if (is_gsharedvt != 0) goto <D.29373>; else goto <D.29378>;
      <D.29378>:
      D.29379 = mini_is_gsharedvt_sharable_method (method);
      if (D.29379 != 0) goto <D.29373>; else goto <D.29374>;
      <D.29373>:
      {
        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.29381>; else goto <D.29384>;
        <D.29384>:
        if (partial == 0) goto <D.29385>; else goto <D.29382>;
        <D.29385>:
        D.29386 = mini_is_gsharedvt_sharable_method (method);
        if (D.29386 != 0) goto <D.29381>; else goto <D.29382>;
        <D.29381>:
        iftmp.78 = 1;
        goto <D.29383>;
        <D.29382>:
        iftmp.78 = 0;
        <D.29383>:
        gsharedvt = iftmp.78;
        D.29370 = declaring_method->klass;
        class_container = D.29370->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        inst = context->class_inst;
        goto <D.29389>;
        <D.29388>:
        inst = shared_context.class_inst;
        <D.29389>:
        if (inst != 0B) goto <D.29390>; else goto <D.29391>;
        <D.29390>:
        D.29392 = shared_context.class_inst;
        D.29393 = get_shared_inst (inst, D.29392, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.29393;
        <D.29391>:
        if (context != 0B) goto <D.29394>; else goto <D.29395>;
        <D.29394>:
        inst = context->method_inst;
        goto <D.29396>;
        <D.29395>:
        inst = shared_context.method_inst;
        <D.29396>:
        if (inst != 0B) goto <D.29397>; else goto <D.29398>;
        <D.29397>:
        D.29399 = shared_context.method_inst;
        D.29400 = get_shared_inst (inst, D.29399, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.29400;
        <D.29398>:
        partial = 1;
      }
      <D.29374>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.29401>; else goto <D.29402>;
      <D.29401>:
      D.29403 = res->klass;
      D.29404 = BIT_FIELD_REF <*D.29403, 8, 288>;
      D.29405 = D.29404 & 8;
      D.29406 = D.29405 != 0;
      D.29407 = (long int) D.29406;
      D.29408 = __builtin_expect (D.29407, 0);
      if (D.29408 != 0) goto <D.29409>; else goto <D.29410>;
      <D.29409>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.29410>:
      <D.29402>:
      D.29411 = res;
      return D.29411;
    }
  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.29414;
  long unsigned int D.29415;
  long unsigned int D.29416;
  struct MonoType * D.29421;
  int D.29422;
  unsigned char D.29424;
  long unsigned int D.29426;
  long unsigned int D.29427;
  struct MonoType * * D.29428;
  struct MonoType * D.29429;
  struct MonoType * D.29432;
  struct MonoType * D.29436;
  int D.29438;
  struct MonoGenericInst * D.29439;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.29414 = inst->type_argc;
  D.29415 = (long unsigned int) D.29414;
  D.29416 = D.29415 * 8;
  type_argv = monoeg_malloc0 (D.29416);
  i = 0;
  goto <D.26287>;
  <D.26286>:
  if (all_vt == 0) goto <D.29420>; else goto <D.29417>;
  <D.29420>:
  D.29421 = inst->type_argv[i];
  D.29422 = mono_type_is_reference (D.29421);
  if (D.29422 != 0) goto <D.29418>; else goto <D.29423>;
  <D.29423>:
  D.29421 = inst->type_argv[i];
  D.29424 = D.29421->type;
  if (D.29424 == 19) goto <D.29418>; else goto <D.29425>;
  <D.29425>:
  D.29421 = inst->type_argv[i];
  D.29424 = D.29421->type;
  if (D.29424 == 30) goto <D.29418>; else goto <D.29417>;
  <D.29418>:
  D.29426 = (long unsigned int) i;
  D.29427 = D.29426 * 8;
  D.29428 = type_argv + D.29427;
  D.29429 = shared_inst->type_argv[i];
  *D.29428 = D.29429;
  goto <D.29419>;
  <D.29417>:
  if (all_vt != 0) goto <D.29430>; else goto <D.29431>;
  <D.29430>:
  D.29426 = (long unsigned int) i;
  D.29427 = D.29426 * 8;
  D.29428 = type_argv + D.29427;
  D.29429 = shared_inst->type_argv[i];
  D.29432 = get_gsharedvt_type (D.29429);
  *D.29428 = D.29432;
  goto <D.29433>;
  <D.29431>:
  if (gsharedvt != 0) goto <D.29434>; else goto <D.29435>;
  <D.29434>:
  D.29426 = (long unsigned int) i;
  D.29427 = D.29426 * 8;
  D.29428 = type_argv + D.29427;
  D.29429 = shared_inst->type_argv[i];
  D.29436 = get_gsharedvt_type (D.29429);
  *D.29428 = D.29436;
  goto <D.29437>;
  <D.29435>:
  D.29426 = (long unsigned int) i;
  D.29427 = D.29426 * 8;
  D.29428 = type_argv + D.29427;
  D.29421 = inst->type_argv[i];
  *D.29428 = D.29421;
  <D.29437>:
  <D.29433>:
  <D.29419>:
  i = i + 1;
  <D.26287>:
  D.29414 = inst->type_argc;
  D.29438 = (int) D.29414;
  if (D.29438 > i) goto <D.26286>; else goto <D.26288>;
  <D.26288>:
  D.29414 = inst->type_argc;
  D.29438 = (int) D.29414;
  res = mono_metadata_get_generic_inst (D.29438, type_argv);
  monoeg_g_free (type_argv);
  D.29439 = res;
  return D.29439;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.79;
  struct MonoGenericContainer * D.29445;
  struct MonoGenericParamInfo * D.29447;
  _Bool D.29448;
  long int D.29449;
  long int D.29450;
  struct GHashTable * D.29455;
  struct GHashTable * D.29458;
  struct MonoType * D.29461;
  struct MonoImage * D.29463;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.29445 = par->owner;
  if (D.29445 == 0B) goto <D.29442>; else goto <D.29446>;
  <D.29446>:
  D.29447 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.29447 == 0B) goto <D.29442>; else goto <D.29443>;
  <D.29442>:
  iftmp.79 = 1;
  goto <D.29444>;
  <D.29443>:
  iftmp.79 = 0;
  <D.29444>:
  D.29448 = iftmp.79 != 0;
  D.29449 = (long int) D.29448;
  D.29450 = __builtin_expect (D.29449, 0);
  if (D.29450 != 0) goto <D.29451>; else goto <D.29452>;
  <D.29451>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.29452>:
  D.29445 = par->owner;
  if (D.29445 != 0B) goto <D.29453>; else goto <D.29454>;
  <D.29453>:
  D.29445 = par->owner;
  image = D.29445->image;
  mono_image_lock (image);
  D.29455 = image->gsharedvt_types;
  if (D.29455 == 0B) goto <D.29456>; else goto <D.29457>;
  <D.29456>:
  D.29458 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.29458;
  <D.29457>:
  D.29455 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.29455, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.29459>; else goto <D.29460>;
  <D.29459>:
  D.29461 = res;
  return D.29461;
  <D.29460>:
  copy = mono_image_alloc0 (image, 56);
  memcpy (copy, par, 56);
  goto <D.29462>;
  <D.29454>:
  copy = monoeg_g_memdup (par, 56);
  <D.29462>:
  copy->owner = 0B;
  D.29463 = mono_defaults.corlib;
  copy->image = D.29463;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.29445 = par->owner;
  if (D.29445 != 0B) goto <D.29464>; else goto <D.29465>;
  <D.29464>:
  mono_image_lock (image);
  D.29455 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.29455, par, res, 0);
  mono_image_unlock (image);
  <D.29465>:
  D.29461 = res;
  return D.29461;
}


mini_get_shared_method (struct MonoMethod * method)
{
  struct MonoMethod * D.29467;

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


mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.29469;
  <unnamed-unsigned:22> D.29472;
  long unsigned int D.29473;
  long unsigned int D.29474;
  void * D.29475;
  unsigned char D.29476;
  _Bool D.29477;
  _Bool D.29478;
  _Bool D.29479;
  struct MonoGenericParam * D.29482;
  short unsigned int D.29483;
  gboolean * D.29486;
  long unsigned int D.29487;
  long unsigned int D.29488;
  gboolean * D.29489;
  int D.29490;
  struct MonoGenericInst * D.29491;
  void * D.29494;
  unsigned char D.29495;
  _Bool D.29496;
  _Bool D.29497;
  _Bool D.29498;
  struct MonoGenericParam * D.29501;
  short unsigned int D.29502;
  gboolean * D.29505;
  gboolean * D.29506;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 16);
  D.29469 = context->class_inst;
  if (D.29469 != 0B) goto <D.29470>; else goto <D.29471>;
  <D.29470>:
  inst = context->class_inst;
  D.29472 = inst->type_argc;
  D.29473 = (long unsigned int) D.29472;
  D.29474 = D.29473 * 4;
  D.29475 = monoeg_malloc0 (D.29474);
  gsctx->var_is_vt = D.29475;
  i = 0;
  goto <D.26314>;
  <D.26313>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29476 = type->type;
    D.29477 = D.29476 == 19;
    D.29478 = D.29476 == 30;
    D.29479 = D.29477 | D.29478;
    if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
    <D.29480>:
    D.29482 = type->data.generic_param;
    D.29483 = D.29482->serial;
    if (D.29483 == 1) goto <D.29484>; else goto <D.29485>;
    <D.29484>:
    D.29486 = gsctx->var_is_vt;
    D.29487 = (long unsigned int) i;
    D.29488 = D.29487 * 4;
    D.29489 = D.29486 + D.29488;
    *D.29489 = 1;
    <D.29485>:
    <D.29481>:
  }
  i = i + 1;
  <D.26314>:
  D.29472 = inst->type_argc;
  D.29490 = (int) D.29472;
  if (D.29490 > i) goto <D.26313>; else goto <D.26315>;
  <D.26315>:
  <D.29471>:
  D.29491 = context->method_inst;
  if (D.29491 != 0B) goto <D.29492>; else goto <D.29493>;
  <D.29492>:
  inst = context->method_inst;
  D.29472 = inst->type_argc;
  D.29473 = (long unsigned int) D.29472;
  D.29474 = D.29473 * 4;
  D.29494 = monoeg_malloc0 (D.29474);
  gsctx->mvar_is_vt = D.29494;
  i = 0;
  goto <D.26318>;
  <D.26317>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29495 = type->type;
    D.29496 = D.29495 == 19;
    D.29497 = D.29495 == 30;
    D.29498 = D.29496 | D.29497;
    if (D.29498 != 0) goto <D.29499>; else goto <D.29500>;
    <D.29499>:
    D.29501 = type->data.generic_param;
    D.29502 = D.29501->serial;
    if (D.29502 == 1) goto <D.29503>; else goto <D.29504>;
    <D.29503>:
    D.29505 = gsctx->mvar_is_vt;
    D.29487 = (long unsigned int) i;
    D.29488 = D.29487 * 4;
    D.29506 = D.29505 + D.29488;
    *D.29506 = 1;
    <D.29504>:
    <D.29500>:
  }
  i = i + 1;
  <D.26318>:
  D.29472 = inst->type_argc;
  D.29490 = (int) D.29472;
  if (D.29490 > i) goto <D.26317>; else goto <D.26319>;
  <D.26319>:
  <D.29493>:
}


mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.29507;
  _Bool D.29508;
  unsigned int D.29509;
  _Bool D.29510;
  unsigned int D.29511;
  _Bool D.29512;
  <unnamed type> D.29513;
  unsigned int D.29514;
  int iftmp.80;
  struct MonoClass * D.29525;
  int D.29526;
  unsigned int D.29528;
  unsigned char D.29530;
  unsigned char D.29531;
  struct MonoGenericContainer * D.29533;
  struct MonoGenericClass * D.29535;
  int D.29537;
  int iftmp.81;
  int D.29542;
  int D.29545;
  long unsigned int D.29551;
  long unsigned int D.29552;
  int D.29554;
  long unsigned int D.29557;
  long unsigned int D.29558;
  int D.29559;
  int D.29562;
  int D.29569;
  int D.29572;
  _Bool D.29573;
  long int D.29574;
  long int D.29575;
  _Bool D.29583;
  long int D.29584;
  long int D.29585;
  struct MonoMethod * D.29589;
  struct MonoMethodHeader * D.29590;
  struct MonoMemPool * D.29591;
  <unnamed type> D.29592;
  unsigned char D.29593;
  <unnamed-unsigned:1> D.29594;
  int mini_verbose.82;
  unsigned int mini_verbose.83;
  unsigned char D.29597;
  <unnamed-unsigned:1> D.29598;
  unsigned char D.29599;
  <unnamed-unsigned:1> D.29600;
  <unnamed-unsigned:1> D.29601;
  int D.29602;
  unsigned char D.29603;
  <unnamed-unsigned:1> D.29604;
  int D.29605;
  unsigned char D.29606;
  <unnamed-unsigned:1> D.29607;
  int D.29608;
  unsigned char D.29609;
  <unnamed-unsigned:1> D.29610;
  struct MonoGenericSharingContext * D.29613;
  unsigned char D.29614;
  <unnamed-unsigned:1> D.29615;
  struct GHashTable * D.29616;
  unsigned char D.29617;
  unsigned char D.29618;
  struct GPtrArray * D.29621;
  unsigned char D.29624;
  unsigned char D.29625;
  struct MonoCompile * D.29632;
  struct MonoGenericSharingContext * D.29635;
  int D.29638;
  unsigned char D.29642;
  _Bool D.29643;
  long int D.29644;
  long int D.29645;
  unsigned char D.29651;
  unsigned char D.29652;
  _Bool D.29653;
  long int D.29654;
  long int D.29655;
  _Bool D.29661;
  long int D.29662;
  long int D.29663;
  const char * D.29668;
  gchar * D.29669;
  unsigned char D.29676;
  unsigned int D.29677;
  const char * D.29679;
  gchar * D.29680;
  int D.29683;
  unsigned int D.29686;
  unsigned int D.29687;
  unsigned int D.29688;
  unsigned int D.29689;
  unsigned int D.29690;
  int mono_using_xdebug.84;
  unsigned int D.29696;
  const gchar * D.29697;
  char * D.29703;
  char * D.29705;
  int D.29706;
  int D.26358;
  const gchar * D.29709;
  <unnamed-unsigned:15> D.29712;
  unsigned int D.29713;
  unsigned int D.29714;
  struct MonoMemPool * D.29715;
  void * D.29716;
  unsigned int D.29717;
  const char * iftmp.85;
  int D.29724;
  const char * iftmp.86;
  unsigned int D.29730;
  unsigned int D.29733;
  int count.87;
  int count.88;
  struct MonoExceptionClause * D.29736;
  unsigned char D.29739;
  unsigned char D.29740;
  unsigned char D.29743;
  unsigned char D.29744;
  unsigned int D.29747;
  struct MonoRegState * D.29750;
  unsigned char D.29751;
  unsigned char D.29752;
  struct MonoRegState * D.29755;
  int D.29756;
  unsigned int D.29757;
  unsigned int D.29758;
  int D.29761;
  struct MonoDebugOptions * D.29764;
  int D.29765;
  unsigned int D.29768;
  unsigned int D.29773;
  _Bool D.29780;
  long int D.29781;
  long int D.29782;
  int D.29787;
  unsigned int D.29788;
  unsigned int D.29789;
  unsigned int D.29790;
  int D.29791;
  struct MonoInst * D.29794;
  unsigned char D.29797;
  unsigned char D.29798;
  long int D.29799;
  struct MonoInst * D.29800;
  int D.29801;
  int D.29802;
  const unsigned char * D.29803;
  int D.29804;
  struct MonoBasicBlock * D.29805;
  struct MonoInst * D.29806;
  unsigned int D.29810;
  unsigned int D.29811;
  unsigned int D.29814;
  unsigned int D.29817;
  unsigned int D.29820;
  unsigned int D.29823;
  unsigned int D.29830;
  unsigned int D.29832;
  unsigned int D.29833;
  void * D.29834;
  struct MonoBasicBlock * * D.29835;
  struct MonoBasicBlock * D.29836;
  int dfn.89;
  int D.29838;
  unsigned int D.29839;
  unsigned int D.29842;
  unsigned int D.29843;
  unsigned int D.29844;
  unsigned int D.29847;
  int D.29852;
  struct MonoInst * D.29853;
  struct MonoBasicBlock * * D.29854;
  struct MonoBasicBlock * D.29855;
  short int D.29856;
  unsigned int D.29859;
  unsigned int D.29863;
  unsigned int D.29864;
  unsigned int D.29873;
  unsigned int D.29874;
  unsigned char D.29877;
  unsigned int D.29886;
  unsigned int D.29887;
  unsigned int D.29898;
  unsigned int D.29899;
  unsigned int D.29902;
  void * D.29911;
  unsigned int D.29923;
  struct MonoInst * D.29926;
  unsigned char D.29929;
  _Bool D.29930;
  long int D.29931;
  long int D.29932;
  _Bool D.29935;
  long int D.29936;
  long int D.29937;
  void * D.29940;
  long int D.29941;
  long unsigned int D.29942;
  int D.29943;
  long long int D.29944;
  long long unsigned int D.29945;
  long long unsigned int D.29946;
  unsigned int D.29949;
  unsigned int D.29954;
  unsigned int D.29955;
  void * D.29962;
  long int D.29963;
  unsigned int D.29964;
  unsigned int D.29965;
  regmask_t * D.29968;
  int need_local_opts.90;
  struct MonoInst * D.29983;
  short unsigned int D.29986;
  short unsigned int D.29987;
  _Bool D.29988;
  short unsigned int D.29989;
  _Bool D.29990;
  _Bool D.29991;
  short unsigned int D.29993;
  short unsigned int D.29994;
  struct MonoBasicBlock * * D.29995;
  struct MonoBasicBlock * * D.29996;
  struct MonoBasicBlock * D.29997;
  struct MonoBasicBlock * D.30000;
  short unsigned int D.30007;
  short unsigned int D.30008;
  _Bool D.30009;
  short unsigned int D.30010;
  _Bool D.30011;
  _Bool D.30012;
  short unsigned int D.30014;
  struct MonoInst * D.30016;
  struct MonoInst * D.30018;
  unsigned char D.30019;
  struct MonoBasicBlock * D.30020;
  struct MonoBasicBlock * D.30022;
  unsigned int D.30023;
  unsigned int D.30024;
  short unsigned int D.30025;
  int D.30030;
  unsigned int D.30033;
  struct MonoJitInfo * D.30040;
  unsigned char D.30041;
  unsigned char D.30042;
  struct MonoMethodVar * D.30045;
  long unsigned int D.30046;
  long unsigned int D.30047;
  struct MonoMethodVar * D.30048;
  unsigned int D.30049;
  int D.30050;
  unsigned int i.91;
  char * D.30056;
  int D.30057;
  unsigned char * D.30058;
  struct MonoDomain * D.30061;
  union mono_mutex_t * D.30062;
  _Bool D.30065;
  long int D.30066;
  long int D.30067;
  struct MonoJitInfo * D.30070;
  unsigned char D.30071;
  struct MonoJitDynamicMethodInfo * D.30074;
  _Bool D.30077;
  long int D.30078;
  long int D.30079;
  struct MonoPerfCounters * mono_perfcounters.92;
  unsigned int D.30083;
  unsigned int D.30084;
  unsigned int D.30085;
  unsigned int D.30086;
  int D.30087;
  unsigned int D.30088;
  unsigned int D.30089;
  int D.30090;
  int D.30091;
  int D.30094;
  char * D.30097;
  const char * D.30098;
  const char * D.30099;
  gchar * D.30100;
  int D.30101;
  unsigned int D.30102;
  unsigned int D.30103;
  int D.30104;
  char * D.30109;
  gchar * D.30110;
  int D.30111;
  unsigned int D.30112;
  unsigned int D.30113;
  int D.30114;
  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.29507 = flags & 1;
      D.29508 = D.29507 != 0;
      run_cctors = (gboolean) D.29508;
      D.29509 = flags & 2;
      D.29510 = D.29509 != 0;
      compile_aot = (gboolean) D.29510;
      D.29511 = flags & 4;
      D.29512 = D.29511 != 0;
      full_aot = (gboolean) D.29512;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.29513 = mono_profiler_get_events ();
      D.29514 = D.29513 & 16;
      if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
      <D.29515>:
      mono_profiler_method_jit (method);
      <D.29516>:
      if (0 != 0) goto <D.29517>; else goto <D.29518>;
      <D.29517>:
      <D.29518>:
      if (compile_aot != 0) goto <D.29519>; else goto <D.29520>;
      <D.29519>:
      D.29525 = method->klass;
      D.29526 = mono_class_generic_sharing_enabled (D.29525);
      if (D.29526 != 0) goto <D.29527>; else goto <D.29522>;
      <D.29527>:
      D.29528 = opts & 33554432;
      if (D.29528 != 0) goto <D.29529>; else goto <D.29522>;
      <D.29529>:
      D.29530 = BIT_FIELD_REF <*method, 8, 264>;
      D.29531 = D.29530 & 8;
      if (D.29531 != 0) goto <D.29523>; else goto <D.29532>;
      <D.29532>:
      D.29525 = method->klass;
      D.29533 = D.29525->generic_container;
      if (D.29533 != 0B) goto <D.29523>; else goto <D.29534>;
      <D.29534>:
      D.29525 = method->klass;
      D.29535 = D.29525->generic_class;
      if (D.29535 == 0B) goto <D.29536>; else goto <D.29522>;
      <D.29536>:
      D.29537 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.29537 != 0) goto <D.29523>; else goto <D.29522>;
      <D.29523>:
      iftmp.80 = 1;
      goto <D.29524>;
      <D.29522>:
      iftmp.80 = 0;
      <D.29524>:
      try_generic_shared = iftmp.80;
      goto <D.29538>;
      <D.29520>:
      D.29525 = method->klass;
      D.29542 = mono_class_generic_sharing_enabled (D.29525);
      if (D.29542 != 0) goto <D.29543>; else goto <D.29540>;
      <D.29543>:
      D.29528 = opts & 33554432;
      if (D.29528 != 0) goto <D.29544>; else goto <D.29540>;
      <D.29544>:
      D.29545 = mono_method_is_generic_sharable (method, 0);
      if (D.29545 != 0) goto <D.29546>; else goto <D.29540>;
      <D.29546>:
      iftmp.81 = 1;
      goto <D.29541>;
      <D.29540>:
      iftmp.81 = 0;
      <D.29541>:
      try_generic_shared = iftmp.81;
      <D.29538>:
      D.29528 = opts & 33554432;
      if (D.29528 != 0) goto <D.29547>; else goto <D.29548>;
      <D.29547>:
      if (try_generic_shared != 0) goto <D.29549>; else goto <D.29550>;
      <D.29549>:
      D.29551 = mono_stats.generics_sharable_methods;
      D.29552 = D.29551 + 1;
      mono_stats.generics_sharable_methods = D.29552;
      goto <D.29553>;
      <D.29550>:
      D.29554 = mono_method_is_generic_impl (method);
      if (D.29554 != 0) goto <D.29555>; else goto <D.29556>;
      <D.29555>:
      D.29557 = mono_stats.generics_unsharable_methods;
      D.29558 = D.29557 + 1;
      mono_stats.generics_unsharable_methods = D.29558;
      <D.29556>:
      <D.29553>:
      <D.29548>:
      D.29559 = mini_is_gsharedvt_sharable_method (method);
      if (D.29559 != 0) goto <D.29560>; else goto <D.29561>;
      <D.29560>:
      D.29562 = mono_debug_count ();
      if (D.29562 == 0) goto <D.29563>; else goto <D.29564>;
      <D.29563>:
      try_generic_shared = 0;
      <D.29564>:
      if (compile_aot != 0) goto <D.29565>; else goto <D.29566>;
      <D.29565>:
      try_generic_shared = 0;
      <D.29566>:
      <D.29561>:
      D.29569 = is_gsharedvt_method (method);
      if (D.29569 != 0) goto <D.29567>; else goto <D.29570>;
      <D.29570>:
      if (compile_aot != 0) goto <D.29571>; else goto <D.29568>;
      <D.29571>:
      D.29572 = is_open_method (method);
      if (D.29572 != 0) goto <D.29567>; else goto <D.29568>;
      <D.29567>:
      method_is_gshared = 1;
      D.29573 = compile_aot == 0;
      D.29574 = (long int) D.29573;
      D.29575 = __builtin_expect (D.29574, 0);
      if (D.29575 != 0) goto <D.29576>; else goto <D.29577>;
      <D.29576>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.29577>:
      try_generic_shared = 1;
      <D.29568>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.29578>; else goto <D.29579>;
      <D.29578>:
      method_to_compile = method;
      goto <D.29580>;
      <D.29579>:
      if (try_generic_shared != 0) goto <D.29581>; else goto <D.29582>;
      <D.29581>:
      method_to_compile = mini_get_shared_method (method);
      D.29583 = method_to_compile == 0B;
      D.29584 = (long int) D.29583;
      D.29585 = __builtin_expect (D.29584, 0);
      if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
      <D.29586>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4898, "method_to_compile");
      <D.29587>:
      goto <D.29588>;
      <D.29582>:
      method_to_compile = method;
      <D.29588>:
      <D.29580>:
      cfg = monoeg_malloc0 (1184);
      cfg->method = method_to_compile;
      D.29589 = cfg->method;
      D.29590 = mono_method_get_header (D.29589);
      cfg->header = D.29590;
      D.29591 = mono_mempool_new ();
      cfg->mempool = D.29591;
      cfg->opt = opts;
      D.29592 = mono_profiler_get_events ();
      cfg->prof_options = D.29592;
      D.29593 = (unsigned char) run_cctors;
      D.29594 = (<unnamed-unsigned:1>) D.29593;
      cfg->run_cctors = D.29594;
      cfg->domain = domain;
      mini_verbose.82 = mini_verbose;
      mini_verbose.83 = (unsigned int) mini_verbose.82;
      cfg->verbose_level = mini_verbose.83;
      D.29597 = (unsigned char) compile_aot;
      D.29598 = (<unnamed-unsigned:1>) D.29597;
      cfg->compile_aot = D.29598;
      D.29599 = (unsigned char) full_aot;
      D.29600 = (<unnamed-unsigned:1>) D.29599;
      cfg->full_aot = D.29600;
      D.29601 = method->skip_visibility;
      cfg->skip_visibility = D.29601;
      cfg->orig_method = method;
      D.29602 = debug_options.gen_seq_points;
      D.29603 = (unsigned char) D.29602;
      D.29604 = (<unnamed-unsigned:1>) D.29603;
      cfg->gen_seq_points = D.29604;
      D.29605 = debug_options.explicit_null_checks;
      D.29606 = (unsigned char) D.29605;
      D.29607 = (<unnamed-unsigned:1>) D.29606;
      cfg->explicit_null_checks = D.29607;
      D.29608 = debug_options.soft_breakpoints;
      D.29609 = (unsigned char) D.29608;
      D.29610 = (<unnamed-unsigned:1>) D.29609;
      cfg->soft_breakpoints = D.29610;
      if (try_generic_shared != 0) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      D.29613 = &cfg->gsctx;
      cfg->generic_sharing_context = D.29613;
      <D.29612>:
      D.29614 = (unsigned char) try_llvm;
      D.29615 = (<unnamed-unsigned:1>) D.29614;
      cfg->compile_llvm = D.29615;
      D.29616 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.29616;
      D.29617 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.29618 = D.29617 & 32;
      if (D.29618 != 0) goto <D.29619>; else goto <D.29620>;
      <D.29619>:
      D.29621 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.29621;
      <D.29620>:
      D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.29625 = D.29624 & 64;
      if (D.29625 != 0) goto <D.29626>; else goto <D.29627>;
      <D.29626>:
      if (try_generic_shared == 0) goto <D.29628>; else goto <D.29629>;
      <D.29628>:
      D.29530 = BIT_FIELD_REF <*method, 8, 264>;
      D.29531 = D.29530 & 8;
      if (D.29531 != 0) goto <D.29622>; else goto <D.29630>;
      <D.29630>:
      D.29525 = method->klass;
      D.29533 = D.29525->generic_container;
      if (D.29533 != 0B) goto <D.29622>; else goto <D.29631>;
      <D.29631>:
      if (method_is_gshared != 0) goto <D.29622>; else goto <D.29623>;
      <D.29622>:
      cfg->exception_type = 11;
      D.29632 = cfg;
      return D.29632;
      <D.29623>:
      <D.29629>:
      <D.29627>:
      D.29635 = cfg->generic_sharing_context;
      if (D.29635 != 0B) goto <D.29636>; else goto <D.29637>;
      <D.29636>:
      D.29638 = mini_is_gsharedvt_sharable_method (method);
      if (D.29638 != 0) goto <D.29633>; else goto <D.29639>;
      <D.29639>:
      if (method_is_gshared != 0) goto <D.29633>; else goto <D.29634>;
      <D.29633>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.29640>; else goto <D.29641>;
        <D.29640>:
        D.29530 = BIT_FIELD_REF <*method, 8, 264>;
        D.29642 = D.29530 & 16;
        D.29643 = D.29642 == 0;
        D.29644 = (long int) D.29643;
        D.29645 = __builtin_expect (D.29644, 0);
        if (D.29645 != 0) goto <D.29646>; else goto <D.29647>;
        <D.29646>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.29647>:
        inflated = method;
        context = &inflated->context;
        D.29573 = compile_aot == 0;
        D.29574 = (long int) D.29573;
        D.29575 = __builtin_expect (D.29574, 0);
        if (D.29575 != 0) goto <D.29648>; else goto <D.29649>;
        <D.29648>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.29649>:
        goto <D.29650>;
        <D.29641>:
        D.29651 = BIT_FIELD_REF <*method_to_compile, 8, 264>;
        D.29652 = D.29651 & 16;
        D.29653 = D.29652 == 0;
        D.29654 = (long int) D.29653;
        D.29655 = __builtin_expect (D.29654, 0);
        if (D.29655 != 0) goto <D.29656>; else goto <D.29657>;
        <D.29656>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.29657>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.29650>:
        D.29613 = &cfg->gsctx;
        mini_init_gsctx (context, D.29613);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.29634>:
      <D.29637>:
      D.29635 = cfg->generic_sharing_context;
      if (D.29635 != 0B) goto <D.29658>; else goto <D.29659>;
      <D.29658>:
      method_to_register = method_to_compile;
      goto <D.29660>;
      <D.29659>:
      D.29661 = method != method_to_compile;
      D.29662 = (long int) D.29661;
      D.29663 = __builtin_expect (D.29662, 0);
      if (D.29663 != 0) goto <D.29664>; else goto <D.29665>;
      <D.29664>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.29665>:
      method_to_register = method;
      <D.29660>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.29589 = cfg->method;
      sig = mono_method_signature_checked (D.29589, &err);
      if (sig == 0B) goto <D.29666>; else goto <D.29667>;
      <D.29666>:
      cfg->exception_type = 7;
      D.29668 = mono_error_get_message (&err);
      D.29669 = monoeg_strdup (D.29668);
      cfg->exception_message = D.29669;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.29670>; else goto <D.29671>;
      <D.29670>:
      <D.29671>:
      D.29632 = cfg;
      return D.29632;
      <D.29667>:
      header = cfg->header;
      if (header == 0B) goto <D.29672>; else goto <D.29673>;
      <D.29672>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.29674>; else goto <D.29675>;
        <D.29674>:
        D.29676 = error->exception_type;
        D.29677 = (unsigned int) D.29676;
        cfg->exception_type = D.29677;
        goto <D.29678>;
        <D.29675>:
        cfg->exception_type = 3;
        D.29589 = cfg->method;
        D.29679 = D.29589->name;
        D.29680 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.29679);
        cfg->exception_message = D.29680;
        <D.29678>:
        if (0 != 0) goto <D.29681>; else goto <D.29682>;
        <D.29681>:
        <D.29682>:
        D.29632 = cfg;
        return D.29632;
      }
      <D.29673>:
      D.29683 = debug_options.mdb_optimizations;
      if (D.29683 != 0) goto <D.29684>; else goto <D.29685>;
      <D.29684>:
      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.29686 = cfg->opt;
      D.29687 = D.29686 & 4294967231;
      cfg->opt = D.29687;
      D.29686 = cfg->opt;
      D.29688 = D.29686 & 4294967291;
      cfg->opt = D.29688;
      D.29686 = cfg->opt;
      D.29689 = D.29686 & 4294967263;
      cfg->opt = D.29689;
      D.29686 = cfg->opt;
      D.29690 = D.29686 & 4294967279;
      cfg->opt = D.29690;
      cfg->disable_out_of_line_bblocks = 1;
      <D.29685>:
      mono_using_xdebug.84 = mono_using_xdebug;
      if (mono_using_xdebug.84 != 0) goto <D.29692>; else goto <D.29693>;
      <D.29692>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.29693>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.29694>; else goto <D.29695>;
      <D.29694>:
      D.29686 = cfg->opt;
      D.29696 = D.29686 | 262144;
      cfg->opt = D.29696;
      <D.29695>:
      D.29697 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.29697 != 0B) goto <D.29698>; else goto <D.29699>;
      <D.29698>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.29703 = __builtin_strchr (name, 46);
        if (D.29703 > name) goto <D.29700>; else goto <D.29704>;
        <D.29704>:
        D.29705 = __builtin_strchr (name, 58);
        if (D.29705 != 0B) goto <D.29700>; else goto <D.29701>;
        <D.29700>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.29589 = cfg->method;
          D.29706 = mono_method_desc_full_match (desc, D.29589);
          if (D.29706 != 0) goto <D.29707>; else goto <D.29708>;
          <D.29707>:
          cfg->verbose_level = 4;
          <D.29708>:
          mono_method_desc_free (desc);
        }
        goto <D.29702>;
        <D.29701>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29709 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
          D.29589 = cfg->method;
          D.29679 = D.29589->name;
          D.26358 = __builtin_strcmp (D.29679, D.29709);
        }
        if (D.26358 == 0) goto <D.29710>; else goto <D.29711>;
        <D.29710>:
        cfg->verbose_level = 4;
        <D.29711>:
        <D.29702>:
      }
      <D.29699>:
      ip = header->code;
      D.29712 = header->max_stack;
      D.29713 = (unsigned int) D.29712;
      D.29714 = D.29713 * 16;
      D.29715 = cfg->mempool;
      D.29716 = mono_mempool_alloc0 (D.29715, D.29714);
      cfg->intvars = D.29716;
      D.29717 = cfg->verbose_level;
      if (D.29717 != 0) goto <D.29718>; else goto <D.29719>;
      <D.29718>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.29635 = cfg->generic_sharing_context;
        if (D.29635 != 0B) goto <D.29723>; else goto <D.29721>;
        <D.29723>:
        D.29724 = cfg->gsharedvt;
        if (D.29724 == 0) goto <D.29725>; else goto <D.29721>;
        <D.29725>:
        iftmp.85 = "gshared ";
        goto <D.29722>;
        <D.29721>:
        iftmp.85 = "";
        <D.29722>:
        D.29724 = cfg->gsharedvt;
        if (D.29724 != 0) goto <D.29727>; else goto <D.29728>;
        <D.29727>:
        iftmp.86 = "gsharedvt ";
        goto <D.29729>;
        <D.29728>:
        iftmp.86 = "";
        <D.29729>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.86, iftmp.85, method_name);
        monoeg_g_free (method_name);
      }
      <D.29719>:
      D.29686 = cfg->opt;
      D.29730 = D.29686 & 786432;
      if (D.29730 != 0) goto <D.29731>; else goto <D.29732>;
      <D.29731>:
      D.29686 = cfg->opt;
      D.29733 = D.29686 | 2097152;
      cfg->opt = D.29733;
      <D.29732>:
      {
        static int count = 0;

        count.87 = count;
        count.88 = count.87 + 1;
        count = count.88;
      }
      D.29736 = header->clauses;
      if (D.29736 != 0B) goto <D.29737>; else goto <D.29738>;
      <D.29737>:
      cfg->globalra = 0;
      <D.29738>:
      D.29589 = cfg->method;
      D.29739 = BIT_FIELD_REF <*D.29589, 8, 256>;
      D.29740 = D.29739 & 124;
      if (D.29740 == 20) goto <D.29741>; else goto <D.29742>;
      <D.29741>:
      cfg->globalra = 0;
      <D.29742>:
      D.29589 = cfg->method;
      D.29743 = BIT_FIELD_REF <*D.29589, 8, 264>;
      D.29744 = D.29743 & 1;
      if (D.29744 != 0) goto <D.29745>; else goto <D.29746>;
      <D.29745>:
      cfg->globalra = 0;
      <D.29746>:
      D.29747 = header->code_size;
      if (D.29747 > 5000) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      cfg->globalra = 0;
      <D.29749>:
      D.29750 = mono_regstate_new ();
      cfg->rs = D.29750;
      D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29752 = D.29751 & 16;
      if (D.29752 != 0) goto <D.29753>; else goto <D.29754>;
      <D.29753>:
      D.29755 = cfg->rs;
      D.29755->next_vreg = 32;
      <D.29754>:
      D.29755 = cfg->rs;
      D.29756 = D.29755->next_vreg;
      D.29757 = (unsigned int) D.29756;
      cfg->next_vreg = D.29757;
      D.29686 = cfg->opt;
      D.29758 = D.29686 & 2097152;
      if (D.29758 != 0) goto <D.29759>; else goto <D.29760>;
      <D.29759>:
      cfg->enable_extended_bblocks = 0;
      <D.29760>:
      D.29589 = cfg->method;
      D.29761 = mono_compile_is_broken (cfg, D.29589, 1);
      if (D.29761 != 0) goto <D.29762>; else goto <D.29763>;
      <D.29762>:
      D.29764 = mini_get_debug_options ();
      D.29765 = D.29764->break_on_unverified;
      if (D.29765 != 0) goto <D.29766>; else goto <D.29767>;
      <D.29766>:
      __asm__ __volatile__("int $03");
      <D.29767>:
      D.29632 = cfg;
      return D.29632;
      <D.29763>:
      mono_compile_create_vars (cfg);
      D.29686 = cfg->opt;
      D.29768 = D.29686 & 4294443007;
      cfg->opt = D.29768;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.29769>; else goto <D.29770>;
      <D.29769>:
      if (try_generic_shared != 0) goto <D.29771>; else goto <D.29772>;
      <D.29771>:
      D.29773 = cfg->exception_type;
      if (D.29773 == 11) goto <D.29774>; else goto <D.29775>;
      <D.29774>:
      if (compile_aot != 0) goto <D.29776>; else goto <D.29777>;
      <D.29776>:
      if (0 != 0) goto <D.29778>; else goto <D.29779>;
      <D.29778>:
      <D.29779>:
      D.29632 = cfg;
      return D.29632;
      <D.29777>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.29775>:
      <D.29772>:
      D.29773 = cfg->exception_type;
      D.29780 = D.29773 == 11;
      D.29781 = (long int) D.29780;
      D.29782 = __builtin_expect (D.29781, 0);
      if (D.29782 != 0) goto <D.29783>; else goto <D.29784>;
      <D.29783>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.29784>:
      if (0 != 0) goto <D.29785>; else goto <D.29786>;
      <D.29785>:
      <D.29786>:
      D.29632 = cfg;
      return D.29632;
      <D.29770>:
      D.29787 = cfg->stat_basic_blocks;
      D.29788 = (unsigned int) D.29787;
      D.29789 = cfg->num_bblocks;
      D.29790 = D.29788 + D.29789;
      D.29791 = (int) D.29790;
      cfg->stat_basic_blocks = D.29791;
      if (0 != 0) goto <D.29792>; else goto <D.29793>;
      <D.29792>:
      {
        struct MonoInst * ins;

        D.29686 = cfg->opt;
        D.29733 = D.29686 | 2097152;
        cfg->opt = D.29733;
        D.29794 = cfg->ret;
        if (D.29794 != 0B) goto <D.29795>; else goto <D.29796>;
        <D.29795>:
        D.29794 = cfg->ret;
        D.29794 = cfg->ret;
        D.29797 = D.29794->flags;
        D.29798 = D.29797 & 251;
        D.29794->flags = D.29798;
        D.29715 = cfg->mempool;
        ins = mono_mempool_alloc (D.29715, 80);
        ins->data.op[1].const_val = 0;
        D.29799 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29799;
        ins->prev = 0B;
        D.29800 = ins->prev;
        ins->next = D.29800;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29801 = ins->sreg3;
        ins->sreg2 = D.29801;
        D.29802 = ins->sreg2;
        ins->sreg1 = D.29802;
        D.29803 = cfg->ip;
        ins->cil_code = D.29803;
        D.29794 = cfg->ret;
        D.29804 = D.29794->dreg;
        ins->sreg1 = D.29804;
        D.29805 = cfg->bb_exit;
        D.29806 = D.29805->last_ins;
        if (D.29806 != 0B) goto <D.29807>; else goto <D.29808>;
        <D.29807>:
        D.29805 = cfg->bb_exit;
        D.29806 = D.29805->last_ins;
        D.29806->next = ins;
        D.29805 = cfg->bb_exit;
        D.29806 = D.29805->last_ins;
        ins->prev = D.29806;
        D.29805 = cfg->bb_exit;
        D.29805->last_ins = ins;
        goto <D.29809>;
        <D.29808>:
        D.29805 = cfg->bb_exit;
        D.29805 = cfg->bb_exit;
        D.29805->last_ins = ins;
        D.29806 = D.29805->last_ins;
        D.29805->code = D.29806;
        <D.29809>:
        <D.29796>:
        D.29686 = cfg->opt;
        D.29810 = D.29686 & 4294967167;
        cfg->opt = D.29810;
        D.29686 = cfg->opt;
        D.29811 = D.29686 & 4294967293;
        cfg->opt = D.29811;
      }
      <D.29793>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.29812>; else goto <D.29813>;
      <D.29812>:
      mono_decompose_long_opts (cfg);
      <D.29813>:
      D.29686 = cfg->opt;
      D.29814 = D.29686 & 48;
      if (D.29814 != 0) goto <D.29815>; else goto <D.29816>;
      <D.29815>:
      mono_local_cprop (cfg);
      <D.29816>:
      D.29686 = cfg->opt;
      D.29817 = D.29686 & 2;
      if (D.29817 != 0) goto <D.29818>; else goto <D.29819>;
      <D.29818>:
      mono_optimize_branches (cfg);
      <D.29819>:
      mono_handle_global_vregs (cfg);
      D.29686 = cfg->opt;
      D.29820 = D.29686 & 64;
      if (D.29820 != 0) goto <D.29821>; else goto <D.29822>;
      <D.29821>:
      mono_local_deadce (cfg);
      <D.29822>:
      D.29686 = cfg->opt;
      D.29823 = D.29686 & 268435456;
      if (D.29823 != 0) goto <D.29824>; else goto <D.29825>;
      <D.29824>:
      mono_local_alias_analysis (cfg);
      <D.29825>:
      if (1 != 0) goto <D.29826>; else goto <D.29827>;
      <D.29826>:
      mono_if_conversion (cfg);
      <D.29827>:
      D.29686 = cfg->opt;
      D.29830 = D.29686 & 524288;
      if (D.29830 != 0) goto <D.29828>; else goto <D.29831>;
      <D.29831>:
      D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29752 = D.29751 & 16;
      if (D.29752 != 0) goto <D.29828>; else goto <D.29829>;
      <D.29828>:
      mono_remove_critical_edges (cfg);
      <D.29829>:
      D.29789 = cfg->num_bblocks;
      D.29832 = D.29789 + 1;
      D.29833 = D.29832 * 8;
      D.29715 = cfg->mempool;
      D.29834 = mono_mempool_alloc (D.29715, D.29833);
      cfg->bblocks = D.29834;
      D.29789 = cfg->num_bblocks;
      cfg->max_block_num = D.29789;
      dfn = 0;
      D.29835 = cfg->bblocks;
      D.29836 = cfg->bb_entry;
      df_visit (D.29836, &dfn, D.29835);
      D.29789 = cfg->num_bblocks;
      dfn.89 = dfn;
      D.29838 = dfn.89 + 1;
      D.29839 = (unsigned int) D.29838;
      if (D.29789 != D.29839) goto <D.29840>; else goto <D.29841>;
      <D.29840>:
      {
        struct MonoBasicBlock * bb;

        dfn.89 = dfn;
        D.29838 = dfn.89 + 1;
        D.29839 = (unsigned int) D.29838;
        cfg->num_bblocks = D.29839;
        bb = cfg->bb_entry;
        goto <D.26364>;
        <D.26363>:
        D.29842 = bb->flags;
        D.29843 = D.29842 & 4294967294;
        bb->flags = D.29843;
        bb = bb->next_bb;
        <D.26364>:
        if (bb != 0B) goto <D.26363>; else goto <D.26365>;
        <D.26365>:
        D.29836 = cfg->bb_entry;
        compute_reachable (D.29836);
        bb = cfg->bb_entry;
        goto <D.26367>;
        <D.26366>:
        D.29842 = bb->flags;
        D.29844 = D.29842 & 16;
        if (D.29844 != 0) goto <D.29845>; else goto <D.29846>;
        <D.29845>:
        compute_reachable (bb);
        <D.29846>:
        bb = bb->next_bb;
        <D.26367>:
        if (bb != 0B) goto <D.26366>; else goto <D.26368>;
        <D.26368>:
        bb = cfg->bb_entry;
        goto <D.26373>;
        <D.26372>:
        D.29842 = bb->flags;
        D.29847 = D.29842 & 1;
        if (D.29847 == 0) goto <D.29848>; else goto <D.29849>;
        <D.29848>:
        D.29717 = cfg->verbose_level;
        if (D.29717 > 1) goto <D.29850>; else goto <D.29851>;
        <D.29850>:
        D.29852 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.29852);
        <D.29851>:
        bb->last_ins = 0B;
        D.29853 = bb->last_ins;
        bb->code = D.29853;
        goto <D.26370>;
        <D.26369>:
        D.29854 = bb->out_bb;
        D.29855 = *D.29854;
        mono_unlink_bblock (cfg, bb, D.29855);
        <D.26370>:
        D.29856 = bb->out_count;
        if (D.29856 != 0) goto <D.26369>; else goto <D.26371>;
        <D.26371>:
        <D.29849>:
        bb = bb->next_bb;
        <D.26373>:
        if (bb != 0B) goto <D.26372>; else goto <D.26374>;
        <D.26374>:
        bb = cfg->bb_entry;
        goto <D.26376>;
        <D.26375>:
        D.29842 = bb->flags;
        D.29843 = D.29842 & 4294967294;
        bb->flags = D.29843;
        bb = bb->next_bb;
        <D.26376>:
        if (bb != 0B) goto <D.26375>; else goto <D.26377>;
        <D.26377>:
      }
      <D.29841>:
      D.29859 = cfg->num_varinfo;
      if (D.29859 > 2000) goto <D.29857>; else goto <D.29860>;
      <D.29860>:
      D.29789 = cfg->num_bblocks;
      if (D.29789 > 1000) goto <D.29857>; else goto <D.29858>;
      <D.29857>:
      D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.29625 = D.29624 & 64;
      if (D.29625 == 0) goto <D.29861>; else goto <D.29862>;
      <D.29861>:
      D.29686 = cfg->opt;
      D.29863 = D.29686 & 4294967119;
      cfg->opt = D.29863;
      cfg->disable_ssa = 1;
      <D.29862>:
      <D.29858>:
      D.29686 = cfg->opt;
      D.29864 = D.29686 & 8192;
      if (D.29864 != 0) goto <D.29865>; else goto <D.29866>;
      <D.29865>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.29866>:
      if (parts == 1) goto <D.29867>; else goto <D.29868>;
      <D.29867>:
      if (0 != 0) goto <D.29869>; else goto <D.29870>;
      <D.29869>:
      <D.29870>:
      D.29632 = cfg;
      return D.29632;
      <D.29868>:
      D.29686 = cfg->opt;
      D.29758 = D.29686 & 2097152;
      if (D.29758 != 0) goto <D.29871>; else goto <D.29872>;
      <D.29871>:
      D.29873 = cfg->comp_done;
      D.29874 = D.29873 & 32;
      if (D.29874 == 0) goto <D.29875>; else goto <D.29876>;
      <D.29875>:
      D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.29877 = D.29624 & 2;
      if (D.29877 == 0) goto <D.29878>; else goto <D.29879>;
      <D.29878>:
      mono_ssa_compute (cfg);
      D.29717 = cfg->verbose_level;
      if (D.29717 > 1) goto <D.29880>; else goto <D.29881>;
      <D.29880>:
      print_dfn (cfg);
      <D.29881>:
      <D.29879>:
      <D.29876>:
      <D.29872>:
      if (parts == 2) goto <D.29882>; else goto <D.29883>;
      <D.29882>:
      if (0 != 0) goto <D.29884>; else goto <D.29885>;
      <D.29884>:
      <D.29885>:
      D.29632 = cfg;
      return D.29632;
      <D.29883>:
      D.29886 = BIT_FIELD_REF <*cfg, 32, 5312>;
      D.29887 = D.29886 & 48;
      if (D.29887 != 0) goto <D.29888>; else goto <D.29889>;
      <D.29888>:
      D.29873 = cfg->comp_done;
      D.29874 = D.29873 & 32;
      if (D.29874 != 0) goto <D.29890>; else goto <D.29891>;
      <D.29890>:
      mono_ssa_cprop (cfg);
      <D.29891>:
      <D.29889>:
      D.29873 = cfg->comp_done;
      D.29874 = D.29873 & 32;
      if (D.29874 != 0) goto <D.29892>; else goto <D.29893>;
      <D.29892>:
      D.29686 = cfg->opt;
      D.29830 = D.29686 & 524288;
      if (D.29830 != 0) goto <D.29894>; else goto <D.29895>;
      <D.29894>:
      mono_perform_ssapre (cfg);
      <D.29895>:
      D.29686 = cfg->opt;
      D.29820 = D.29686 & 64;
      if (D.29820 != 0) goto <D.29896>; else goto <D.29897>;
      <D.29896>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.29897>:
      D.29898 = cfg->flags;
      D.29899 = D.29898 & 132;
      if (D.29899 != 0) goto <D.29900>; else goto <D.29901>;
      <D.29900>:
      D.29686 = cfg->opt;
      D.29902 = D.29686 & 262144;
      if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      mono_perform_abc_removal (cfg);
      <D.29904>:
      <D.29901>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.29686 = cfg->opt;
      D.29820 = D.29686 & 64;
      if (D.29820 != 0) goto <D.29905>; else goto <D.29906>;
      <D.29905>:
      mono_local_deadce (cfg);
      <D.29906>:
      D.29686 = cfg->opt;
      D.29817 = D.29686 & 2;
      if (D.29817 != 0) goto <D.29907>; else goto <D.29908>;
      <D.29907>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.29752 = D.29751 & 16;
        if (D.29752 != 0) goto <D.29909>; else goto <D.29910>;
        <D.29909>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.26380>;
        <D.26379>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.26380>:
        if (bb != 0B) goto <D.26379>; else goto <D.26381>;
        <D.26381>:
        D.29789 = cfg->num_bblocks;
        D.29832 = D.29789 + 1;
        D.29833 = D.29832 * 8;
        D.29715 = cfg->mempool;
        D.29911 = mono_mempool_alloc (D.29715, D.29833);
        cfg->bblocks = D.29911;
        dfn = 0;
        D.29835 = cfg->bblocks;
        D.29836 = cfg->bb_entry;
        df_visit (D.29836, &dfn, D.29835);
        dfn.89 = dfn;
        D.29838 = dfn.89 + 1;
        D.29839 = (unsigned int) D.29838;
        cfg->num_bblocks = D.29839;
        <D.29910>:
      }
      <D.29908>:
      <D.29893>:
      if (0 != 0) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.29686 = cfg->opt;
      D.29902 = D.29686 & 262144;
      if (D.29902 != 0) goto <D.29914>; else goto <D.29915>;
      <D.29914>:
      mono_perform_abc_removal (cfg);
      <D.29915>:
      <D.29913>:
      if (parts == 3) goto <D.29916>; else goto <D.29917>;
      <D.29916>:
      if (0 != 0) goto <D.29918>; else goto <D.29919>;
      <D.29918>:
      <D.29919>:
      D.29632 = cfg;
      return D.29632;
      <D.29917>:
      if (0 != 0) goto <D.29920>; else goto <D.29921>;
      <D.29920>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.29922>;
      <D.29921>:
      mono_decompose_vtype_opts (cfg);
      <D.29922>:
      D.29898 = cfg->flags;
      D.29923 = D.29898 & 256;
      if (D.29923 != 0) goto <D.29924>; else goto <D.29925>;
      <D.29924>:
      mono_decompose_array_access_opts (cfg);
      <D.29925>:
      D.29926 = cfg->got_var;
      if (D.29926 != 0B) goto <D.29927>; else goto <D.29928>;
      <D.29927>:
      {
        struct GList * regs;
        int got_reg;

        D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.29929 = D.29751 & 2;
        D.29930 = D.29929 == 0;
        D.29931 = (long int) D.29930;
        D.29932 = __builtin_expect (D.29931, 0);
        if (D.29932 != 0) goto <D.29933>; else goto <D.29934>;
        <D.29933>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.29934>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29935 = regs == 0B;
        D.29936 = (long int) D.29935;
        D.29937 = __builtin_expect (D.29936, 0);
        if (D.29937 != 0) goto <D.29938>; else goto <D.29939>;
        <D.29938>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5473, "regs");
        <D.29939>:
        D.29940 = regs->data;
        D.29941 = (long int) D.29940;
        got_reg = (int) D.29941;
        monoeg_g_list_free (regs);
        D.29926 = cfg->got_var;
        D.29926->opcode = 366;
        D.29926 = cfg->got_var;
        D.29926->dreg = got_reg;
        D.29942 = cfg->used_int_regs;
        D.29926 = cfg->got_var;
        D.29943 = D.29926->dreg;
        D.29944 = 1 << D.29943;
        D.29945 = (long long unsigned int) D.29944;
        D.29946 = D.29942 | D.29945;
        cfg->used_int_regs = D.29946;
      }
      <D.29928>:
      mono_liveness_handle_exception_clauses (cfg);
      D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29752 = D.29751 & 16;
      if (D.29752 != 0) goto <D.29947>; else goto <D.29948>;
      <D.29947>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.26386>;
        <D.26385>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.26386>:
        if (bb != 0B) goto <D.26385>; else goto <D.26387>;
        <D.26387>:
        mono_global_regalloc (cfg);
      }
      <D.29948>:
      D.29686 = cfg->opt;
      D.29949 = D.29686 & 128;
      if (D.29949 != 0) goto <D.29950>; else goto <D.29951>;
      <D.29950>:
      D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29752 = D.29751 & 16;
      if (D.29752 == 0) goto <D.29952>; else goto <D.29953>;
      <D.29952>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.29873 = cfg->comp_done;
        D.29954 = D.29873 & 4294967279;
        cfg->comp_done = D.29954;
        D.29873 = cfg->comp_done;
        D.29955 = D.29873 & 16;
        if (D.29955 == 0) goto <D.29956>; else goto <D.29957>;
        <D.29956>:
        mono_analyze_liveness (cfg);
        <D.29957>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.29958>; else goto <D.29959>;
        <D.29958>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29926 = cfg->got_var;
        if (D.29926 != 0B) goto <D.29960>; else goto <D.29961>;
        <D.29960>:
        l = regs;
        goto <D.26393>;
        <D.26392>:
        D.29962 = l->data;
        D.29963 = (long int) D.29962;
        D.29964 = (unsigned int) D.29963;
        D.29926 = cfg->got_var;
        D.29943 = D.29926->dreg;
        D.29965 = (unsigned int) D.29943;
        if (D.29964 == D.29965) goto <D.29966>; else goto <D.29967>;
        <D.29966>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.26391>;
        <D.29967>:
        l = l->next;
        <D.26393>:
        if (l != 0B) goto <D.26392>; else goto <D.26391>;
        <D.26391>:
        <D.29961>:
        D.29968 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.29968);
        <D.29959>:
      }
      <D.29953>:
      <D.29951>:
      D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29752 = D.29751 & 16;
      if (D.29752 == 0) goto <D.29969>; else goto <D.29970>;
      <D.29969>:
      mono_arch_allocate_vars (cfg);
      D.29773 = cfg->exception_type;
      if (D.29773 != 0) goto <D.29971>; else goto <D.29972>;
      <D.29971>:
      D.29632 = cfg;
      return D.29632;
      <D.29972>:
      <D.29970>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
            D.29752 = D.29751 & 16;
            if (D.29752 == 0) goto <D.29973>; else goto <D.29974>;
            <D.29973>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.90 = need_local_opts;
            if (need_local_opts.90 != 0) goto <D.29975>; else goto <D.29978>;
            <D.29978>:
            D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
            D.29625 = D.29624 & 64;
            if (D.29625 != 0) goto <D.29975>; else goto <D.29976>;
            <D.29975>:
            mono_local_cprop (cfg);
            D.29686 = cfg->opt;
            D.29820 = D.29686 & 64;
            if (D.29820 != 0) goto <D.29979>; else goto <D.29980>;
            <D.29979>:
            mono_local_deadce (cfg);
            <D.29980>:
            <D.29976>:
            <D.29974>:
            bb = cfg->bb_entry;
            goto <D.26399>;
            <D.26398>:
            D.29983 = bb->last_ins;
            if (D.29983 != 0B) goto <D.29984>; else goto <D.29985>;
            <D.29984>:
            D.29983 = bb->last_ins;
            D.29986 = D.29983->opcode;
            D.29987 = D.29986 + 64981;
            D.29988 = D.29987 <= 9;
            D.29989 = D.29986 + 64874;
            D.29990 = D.29989 <= 9;
            D.29991 = D.29988 | D.29990;
            if (D.29991 != 0) goto <D.29981>; else goto <D.29992>;
            <D.29992>:
            D.29983 = bb->last_ins;
            D.29993 = D.29983->opcode;
            D.29994 = D.29993 + 64884;
            if (D.29994 <= 9) goto <D.29981>; else goto <D.29982>;
            <D.29981>:
            D.29983 = bb->last_ins;
            D.29995 = D.29983->data.op[1].many_blocks;
            D.29996 = D.29995 + 8;
            D.29997 = *D.29996;
            if (D.29997 != 0B) goto <D.29998>; else goto <D.29999>;
            <D.29998>:
            D.30000 = bb->next_bb;
            D.29983 = bb->last_ins;
            D.29995 = D.29983->data.op[1].many_blocks;
            D.29996 = D.29995 + 8;
            D.29997 = *D.29996;
            if (D.30000 != D.29997) goto <D.30001>; else goto <D.30002>;
            <D.30001>:
            D.29983 = bb->last_ins;
            D.30007 = D.29983->opcode;
            D.30008 = D.30007 + 64981;
            D.30009 = D.30008 <= 9;
            D.30010 = D.30007 + 64874;
            D.30011 = D.30010 <= 9;
            D.30012 = D.30009 | D.30011;
            if (D.30012 != 0) goto <D.30003>; else goto <D.30013>;
            <D.30013>:
            D.29983 = bb->last_ins;
            D.29993 = D.29983->opcode;
            D.29994 = D.29993 + 64884;
            if (D.29994 <= 9) goto <D.30003>; else goto <D.30004>;
            <D.30003>:
            D.29983 = bb->last_ins;
            D.29993 = D.29983->opcode;
            D.30014 = D.29993 + 64874;
            if (D.30014 > 9) goto <D.30015>; else goto <D.30004>;
            <D.30015>:
            D.29983 = bb->last_ins;
            D.30016 = D.29983->data.op[0].src;
            if (D.30016 == 0B) goto <D.30005>; else goto <D.30017>;
            <D.30017>:
            D.29983 = bb->last_ins;
            D.30016 = D.29983->data.op[0].src;
            D.30018 = D.30016->data.op[0].src;
            D.30019 = D.30018->type;
            if (D.30019 != 4) goto <D.30005>; else goto <D.30004>;
            <D.30005>:
            D.30000 = bb->next_bb;
            D.29983 = bb->last_ins;
            D.29995 = D.29983->data.op[1].many_blocks;
            D.30020 = *D.29995;
            if (D.30000 == D.30020) goto <D.30021>; else goto <D.30004>;
            <D.30021>:
            {
              struct MonoBasicBlock * tmp;

              D.29983 = bb->last_ins;
              D.29995 = D.29983->data.op[1].many_blocks;
              tmp = *D.29995;
              D.29983 = bb->last_ins;
              D.29995 = D.29983->data.op[1].many_blocks;
              D.29983 = bb->last_ins;
              D.29995 = D.29983->data.op[1].many_blocks;
              D.30022 = MEM[(struct MonoBasicBlock * *)D.29995 + 8B];
              *D.29995 = D.30022;
              D.29983 = bb->last_ins;
              D.29995 = D.29983->data.op[1].many_blocks;
              D.29996 = D.29995 + 8;
              *D.29996 = tmp;
              D.29983 = bb->last_ins;
              D.29983 = bb->last_ins;
              D.29993 = D.29983->opcode;
              D.30023 = (unsigned int) D.29993;
              D.30024 = mono_reverse_branch_op (D.30023);
              D.30025 = (short unsigned int) D.30024;
              D.29983->opcode = D.30025;
            }
            goto <D.30006>;
            <D.30004>:
            {
              struct MonoInst * inst;

              D.29715 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.29715, 80);
              inst->opcode = 446;
              D.29983 = bb->last_ins;
              D.29995 = D.29983->data.op[1].many_blocks;
              D.30022 = MEM[(struct MonoBasicBlock * *)D.29995 + 8B];
              inst->data.op[0].target_block = D.30022;
              mono_bblock_add_inst (bb, inst);
            }
            <D.30006>:
            <D.30002>:
            <D.29999>:
            <D.29982>:
            <D.29985>:
            bb = bb->next_bb;
            <D.26399>:
            if (bb != 0B) goto <D.26398>; else goto <D.26400>;
            <D.26400>:
            D.29717 = cfg->verbose_level;
            if (D.29717 > 3) goto <D.30026>; else goto <D.30027>;
            <D.30026>:
            D.29751 = BIT_FIELD_REF <*cfg, 8, 5608>;
            D.29752 = D.29751 & 16;
            if (D.29752 == 0) goto <D.30028>; else goto <D.30029>;
            <D.30028>:
            bb = cfg->bb_entry;
            goto <D.26407>;
            <D.26406>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.30030 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.30030);
              if (tree == 0B) goto <D.30031>; else goto <D.30032>;
              <D.30031>:
              // predicted unlikely by continue predictor.
              goto <D.26402>;
              <D.30032>:
              goto <D.26404>;
              <D.26403>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.26404>:
              if (tree != 0B) goto <D.26403>; else goto <D.26405>;
              <D.26405>:
            }
            <D.26402>:
            bb = bb->next_bb;
            <D.26407>:
            if (bb != 0B) goto <D.26406>; else goto <D.26408>;
            <D.26408>:
            <D.30029>:
            <D.30027>:
            bb = cfg->bb_entry;
            goto <D.26410>;
            <D.26409>:
            D.30033 = cfg->next_vreg;
            bb->max_vreg = D.30033;
            bb = bb->next_bb;
            <D.26410>:
            if (bb != 0B) goto <D.26409>; else goto <D.26411>;
            <D.26411>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.30034>; else goto <D.30035>;
      <D.30034>:
      goto <D.30036>;
      <D.30035>:
      mono_codegen (cfg);
      <D.30036>:
      if (0 != 0) goto <D.30037>; else goto <D.30038>;
      <D.30037>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.30039>;
      <D.30038>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.30039>:
      D.30040 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.30040;
      D.30041 = BIT_FIELD_REF <*cfg, 8, 5624>;
      D.30042 = D.30041 & 64;
      if (D.30042 != 0) goto <D.30043>; else goto <D.30044>;
      <D.30043>:
      i = 0;
      goto <D.26413>;
      <D.26412>:
      D.30045 = cfg->vars;
      D.30046 = (long unsigned int) i;
      D.30047 = D.30046 * 80;
      D.30048 = D.30045 + D.30047;
      D.30049 = cfg->code_len;
      D.30050 = (int) D.30049;
      D.30048->live_range_end = D.30050;
      i = i + 1;
      <D.26413>:
      i.91 = (unsigned int) i;
      D.29859 = cfg->num_varinfo;
      if (i.91 < D.29859) goto <D.26412>; else goto <D.26414>;
      <D.26414>:
      <D.30044>:
      D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.29625 = D.29624 & 64;
      if (D.29625 == 0) goto <D.30052>; else goto <D.30053>;
      <D.30052>:
      mono_save_xdebug_info (cfg);
      <D.30053>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.29717 = cfg->verbose_level;
      if (D.29717 > 1) goto <D.30054>; else goto <D.30055>;
      <D.30054>:
      {
        char * id;

        D.29589 = cfg->method;
        id = mono_method_full_name (D.29589, 0);
        D.30056 = id + 3;
        D.30049 = cfg->code_len;
        D.30057 = (int) D.30049;
        D.30058 = cfg->native_code;
        mono_disassemble_code (cfg, D.30058, D.30057, D.30056);
        monoeg_g_free (id);
      }
      <D.30055>:
      D.29624 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.29625 = D.29624 & 64;
      if (D.29625 == 0) goto <D.30059>; else goto <D.30060>;
      <D.30059>:
      {
        int ret;

        D.30061 = cfg->domain;
        D.30062 = &D.30061->lock.mutex;
        ret = pthread_mutex_lock (D.30062);
        if (ret != 0) goto <D.30063>; else goto <D.30064>;
        <D.30063>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30064>:
        D.30065 = ret != 0;
        D.30066 = (long int) D.30065;
        D.30067 = __builtin_expect (D.30066, 0);
        if (D.30067 != 0) goto <D.30068>; else goto <D.30069>;
        <D.30068>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.30069>:
      }
      D.30070 = cfg->jit_info;
      D.30061 = cfg->domain;
      mono_jit_info_table_add (D.30061, D.30070);
      D.29589 = cfg->method;
      D.29743 = BIT_FIELD_REF <*D.29589, 8, 264>;
      D.30071 = D.29743 & 2;
      if (D.30071 != 0) goto <D.30072>; else goto <D.30073>;
      <D.30072>:
      D.29589 = cfg->method;
      D.30061 = cfg->domain;
      D.30074 = mono_dynamic_code_hash_lookup (D.30061, D.29589);
      D.30070 = cfg->jit_info;
      D.30074->ji = D.30070;
      <D.30073>:
      {
        int ret;

        D.30061 = cfg->domain;
        D.30062 = &D.30061->lock.mutex;
        ret = pthread_mutex_unlock (D.30062);
        if (ret != 0) goto <D.30075>; else goto <D.30076>;
        <D.30075>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30076>:
        D.30077 = ret != 0;
        D.30078 = (long int) D.30077;
        D.30079 = __builtin_expect (D.30078, 0);
        if (D.30079 != 0) goto <D.30080>; else goto <D.30081>;
        <D.30080>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.30081>:
      }
      <D.30060>:
      mono_perfcounters.92 = mono_perfcounters;
      D.30083 = mono_perfcounters.92->jit_methods;
      D.30084 = D.30083 + 1;
      mono_perfcounters.92->jit_methods = D.30084;
      mono_perfcounters.92 = mono_perfcounters;
      mono_perfcounters.92 = mono_perfcounters;
      D.30085 = mono_perfcounters.92->jit_bytes;
      D.29747 = header->code_size;
      D.30086 = D.30085 + D.29747;
      mono_perfcounters.92->jit_bytes = D.30086;
      D.30087 = mono_jit_stats.allocated_code_size;
      D.30088 = (unsigned int) D.30087;
      D.30049 = cfg->code_len;
      D.30089 = D.30088 + D.30049;
      D.30090 = (int) D.30089;
      mono_jit_stats.allocated_code_size = D.30090;
      D.30049 = cfg->code_len;
      code_size_ratio = (int) D.30049;
      D.30091 = mono_jit_stats.biggest_method_size;
      if (D.30091 < code_size_ratio) goto <D.30092>; else goto <D.30093>;
      <D.30092>:
      D.30094 = mono_jit_stats.enabled;
      if (D.30094 != 0) goto <D.30095>; else goto <D.30096>;
      <D.30095>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.30097 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.30097);
      D.30098 = method->name;
      D.29525 = method->klass;
      D.30099 = D.29525->name;
      D.30100 = monoeg_g_strdup_printf ("%s::%s)", D.30099, D.30098);
      mono_jit_stats.biggest_method = D.30100;
      <D.30096>:
      <D.30093>:
      D.30101 = code_size_ratio * 100;
      D.30102 = (unsigned int) D.30101;
      D.29747 = header->code_size;
      D.30103 = D.30102 / D.29747;
      code_size_ratio = (int) D.30103;
      D.30104 = mono_jit_stats.max_code_size_ratio;
      if (D.30104 < code_size_ratio) goto <D.30105>; else goto <D.30106>;
      <D.30105>:
      D.30094 = mono_jit_stats.enabled;
      if (D.30094 != 0) goto <D.30107>; else goto <D.30108>;
      <D.30107>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.30109 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.30109);
      D.30098 = method->name;
      D.29525 = method->klass;
      D.30099 = D.29525->name;
      D.30110 = monoeg_g_strdup_printf ("%s::%s)", D.30099, D.30098);
      mono_jit_stats.max_ratio_method = D.30110;
      <D.30108>:
      <D.30106>:
      D.30111 = mono_jit_stats.native_code_size;
      D.30112 = (unsigned int) D.30111;
      D.30049 = cfg->code_len;
      D.30113 = D.30112 + D.30049;
      D.30114 = (int) D.30113;
      mono_jit_stats.native_code_size = D.30114;
      if (0 != 0) goto <D.30115>; else goto <D.30116>;
      <D.30115>:
      <D.30116>:
      D.29632 = cfg;
      return D.29632;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  unsigned char D.30119;
  unsigned char D.30120;
  gboolean D.30123;
  struct MonoType * D.30126;
  int D.30127;
  <unnamed-unsigned:22> D.30130;
  int D.30131;
  int D.30134;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.30119 = BIT_FIELD_REF <*method, 8, 264>;
  D.30120 = D.30119 & 16;
  if (D.30120 == 0) goto <D.30121>; else goto <D.30122>;
  <D.30121>:
  D.30123 = 0;
  return D.30123;
  <D.30122>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.30124>; else goto <D.30125>;
  <D.30124>:
  i = 0;
  goto <D.26267>;
  <D.26266>:
  D.30126 = inst->type_argv[i];
  D.30127 = is_gsharedvt_type (D.30126);
  if (D.30127 != 0) goto <D.30128>; else goto <D.30129>;
  <D.30128>:
  D.30123 = 1;
  return D.30123;
  <D.30129>:
  i = i + 1;
  <D.26267>:
  D.30130 = inst->type_argc;
  D.30131 = (int) D.30130;
  if (D.30131 > i) goto <D.26266>; else goto <D.26268>;
  <D.26268>:
  <D.30125>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.30132>; else goto <D.30133>;
  <D.30132>:
  i = 0;
  goto <D.26270>;
  <D.26269>:
  D.30126 = inst->type_argv[i];
  D.30134 = is_gsharedvt_type (D.30126);
  if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
  <D.30135>:
  D.30123 = 1;
  return D.30123;
  <D.30136>:
  i = i + 1;
  <D.26270>:
  D.30130 = inst->type_argc;
  D.30131 = (int) D.30130;
  if (D.30131 > i) goto <D.26269>; else goto <D.26271>;
  <D.26271>:
  <D.30133>:
  D.30123 = 0;
  return D.30123;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.30138;
  int iftmp.93;
  unsigned char D.30142;
  _Bool D.30143;
  _Bool D.30144;
  _Bool D.30145;
  struct MonoGenericParam * D.30147;
  short unsigned int D.30148;

  D.30142 = t->type;
  D.30143 = D.30142 == 19;
  D.30144 = D.30142 == 30;
  D.30145 = D.30143 | D.30144;
  if (D.30145 != 0) goto <D.30146>; else goto <D.30140>;
  <D.30146>:
  D.30147 = t->data.generic_param;
  D.30148 = D.30147->serial;
  if (D.30148 == 1) goto <D.30149>; else goto <D.30140>;
  <D.30149>:
  iftmp.93 = 1;
  goto <D.30141>;
  <D.30140>:
  iftmp.93 = 0;
  <D.30141>:
  D.30138 = iftmp.93;
  return D.30138;
}


is_open_method (struct MonoMethod * method)
{
  unsigned char D.30151;
  unsigned char D.30152;
  gboolean D.30155;
  struct MonoGenericInst * D.30156;
  unsigned char D.30159;
  unsigned char D.30160;
  struct MonoGenericInst * D.30163;
  unsigned char D.30166;
  unsigned char D.30167;
  struct MonoGenericContext * context;

  D.30151 = BIT_FIELD_REF <*method, 8, 264>;
  D.30152 = D.30151 & 16;
  if (D.30152 == 0) goto <D.30153>; else goto <D.30154>;
  <D.30153>:
  D.30155 = 0;
  return D.30155;
  <D.30154>:
  context = mono_method_get_context (method);
  D.30156 = context->class_inst;
  if (D.30156 != 0B) goto <D.30157>; else goto <D.30158>;
  <D.30157>:
  D.30156 = context->class_inst;
  D.30159 = BIT_FIELD_REF <*D.30156, 8, 48>;
  D.30160 = D.30159 & 64;
  if (D.30160 != 0) goto <D.30161>; else goto <D.30162>;
  <D.30161>:
  D.30155 = 1;
  return D.30155;
  <D.30162>:
  <D.30158>:
  D.30163 = context->method_inst;
  if (D.30163 != 0B) goto <D.30164>; else goto <D.30165>;
  <D.30164>:
  D.30163 = context->method_inst;
  D.30166 = BIT_FIELD_REF <*D.30163, 8, 48>;
  D.30167 = D.30166 & 64;
  if (D.30167 != 0) goto <D.30168>; else goto <D.30169>;
  <D.30168>:
  D.30155 = 1;
  return D.30155;
  <D.30169>:
  <D.30165>:
  D.30155 = 0;
  return D.30155;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30171;
  struct MonoType * D.30172;
  int D.30173;
  struct MonoInst * D.30176;
  struct MonoInst * D.30177;
  unsigned char D.30178;
  unsigned char D.30179;
  unsigned int D.30180;
  short unsigned int D.30183;
  int D.30184;
  <unnamed-unsigned:1> D.30185;
  int D.30186;
  int D.30187;
  long unsigned int D.30188;
  unsigned int D.30189;
  unsigned int D.30190;
  struct MonoMemPool * D.30191;
  void * D.30192;
  unsigned char D.30193;
  unsigned char D.30194;
  struct MonoInst * * D.30197;
  struct MonoClass * D.30198;
  struct MonoType * D.30199;
  struct MonoInst * D.30200;
  int D.30201;
  long unsigned int D.30202;
  long unsigned int D.30203;
  struct MonoInst * * D.30204;
  struct MonoType * D.30205;
  struct MonoInst * D.30206;
  struct MonoInst * D.30213;
  struct MonoInst * D.30214;
  unsigned int D.30215;
  short unsigned int D.30216;
  unsigned int D.30217;
  unsigned int D.30218;
  void * D.30219;
  struct MonoInst * * D.30222;
  long unsigned int D.30223;
  long unsigned int D.30224;
  struct MonoInst * * D.30225;
  struct MonoType * D.30226;
  struct MonoInst * D.30227;
  int D.30228;
  unsigned char D.30231;
  unsigned char D.30232;
  unsigned char D.30235;
  unsigned char D.30236;
  struct MonoClass * D.30239;
  struct MonoType * D.30240;
  unsigned char D.30241;
  unsigned char D.30242;
  unsigned char D.30243;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.30171 = cfg->method;
  sig = mono_method_signature (D.30171);
  D.30172 = sig->ret;
  D.30173 = mono_type_is_void (D.30172);
  if (D.30173 == 0) goto <D.30174>; else goto <D.30175>;
  <D.30174>:
  D.30172 = sig->ret;
  D.30176 = mono_compile_create_var (cfg, D.30172, 330);
  cfg->ret = D.30176;
  D.30177 = cfg->ret;
  D.30177 = cfg->ret;
  D.30178 = D.30177->flags;
  D.30179 = D.30178 | 4;
  D.30177->flags = D.30179;
  <D.30175>:
  D.30180 = cfg->verbose_level;
  if (D.30180 > 2) goto <D.30181>; else goto <D.30182>;
  <D.30181>:
  monoeg_g_print ("creating vars\n");
  <D.30182>:
  D.30183 = sig->param_count;
  D.30184 = (int) D.30183;
  D.30185 = sig->hasthis;
  D.30186 = (int) D.30185;
  D.30187 = D.30184 + D.30186;
  D.30188 = (long unsigned int) D.30187;
  D.30189 = (unsigned int) D.30188;
  D.30190 = D.30189 * 8;
  D.30191 = cfg->mempool;
  D.30192 = mono_mempool_alloc0 (D.30191, D.30190);
  cfg->args = D.30192;
  D.30193 = BIT_FIELD_REF <*sig, 8, 112>;
  D.30194 = D.30193 & 64;
  if (D.30194 != 0) goto <D.30195>; else goto <D.30196>;
  <D.30195>:
  D.30197 = cfg->args;
  D.30171 = cfg->method;
  D.30198 = D.30171->klass;
  D.30199 = &D.30198->this_arg;
  D.30200 = mono_compile_create_var (cfg, D.30199, 330);
  *D.30197 = D.30200;
  <D.30196>:
  i = 0;
  goto <D.26023>;
  <D.26022>:
  D.30197 = cfg->args;
  D.30185 = sig->hasthis;
  D.30186 = (int) D.30185;
  D.30201 = D.30186 + i;
  D.30202 = (long unsigned int) D.30201;
  D.30203 = D.30202 * 8;
  D.30204 = D.30197 + D.30203;
  D.30205 = sig->params[i];
  D.30206 = mono_compile_create_var (cfg, D.30205, 330);
  *D.30204 = D.30206;
  i = i + 1;
  <D.26023>:
  D.30183 = sig->param_count;
  D.30184 = (int) D.30183;
  if (D.30184 > i) goto <D.26022>; else goto <D.26024>;
  <D.26024>:
  D.30180 = cfg->verbose_level;
  if (D.30180 > 2) goto <D.30207>; else goto <D.30208>;
  <D.30207>:
  D.30177 = cfg->ret;
  if (D.30177 != 0B) goto <D.30209>; else goto <D.30210>;
  <D.30209>:
  printf ("\treturn : ");
  D.30177 = cfg->ret;
  mono_print_ins (D.30177);
  <D.30210>:
  D.30193 = BIT_FIELD_REF <*sig, 8, 112>;
  D.30194 = D.30193 & 64;
  if (D.30194 != 0) goto <D.30211>; else goto <D.30212>;
  <D.30211>:
  printf ("\tthis: ");
  D.30197 = cfg->args;
  D.30213 = *D.30197;
  mono_print_ins (D.30213);
  <D.30212>:
  i = 0;
  goto <D.26026>;
  <D.26025>:
  printf ("\targ [%d]: ", i);
  D.30197 = cfg->args;
  D.30185 = sig->hasthis;
  D.30186 = (int) D.30185;
  D.30201 = D.30186 + i;
  D.30202 = (long unsigned int) D.30201;
  D.30203 = D.30202 * 8;
  D.30204 = D.30197 + D.30203;
  D.30214 = *D.30204;
  mono_print_ins (D.30214);
  i = i + 1;
  <D.26026>:
  D.30183 = sig->param_count;
  D.30184 = (int) D.30183;
  if (D.30184 > i) goto <D.26025>; else goto <D.26027>;
  <D.26027>:
  <D.30208>:
  D.30215 = cfg->num_varinfo;
  cfg->locals_start = D.30215;
  D.30216 = header->num_locals;
  D.30217 = (unsigned int) D.30216;
  D.30218 = D.30217 * 8;
  D.30191 = cfg->mempool;
  D.30219 = mono_mempool_alloc0 (D.30191, D.30218);
  cfg->locals = D.30219;
  D.30180 = cfg->verbose_level;
  if (D.30180 > 2) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  monoeg_g_print ("creating locals\n");
  <D.30221>:
  i = 0;
  goto <D.26029>;
  <D.26028>:
  D.30222 = cfg->locals;
  D.30223 = (long unsigned int) i;
  D.30224 = D.30223 * 8;
  D.30225 = D.30222 + D.30224;
  D.30226 = header->locals[i];
  D.30227 = mono_compile_create_var (cfg, D.30226, 329);
  *D.30225 = D.30227;
  i = i + 1;
  <D.26029>:
  D.30216 = header->num_locals;
  D.30228 = (int) D.30216;
  if (D.30228 > i) goto <D.26028>; else goto <D.26030>;
  <D.26030>:
  D.30180 = cfg->verbose_level;
  if (D.30180 > 2) goto <D.30229>; else goto <D.30230>;
  <D.30229>:
  monoeg_g_print ("locals done\n");
  <D.30230>:
  mono_arch_create_vars (cfg);
  D.30171 = cfg->method;
  D.30231 = BIT_FIELD_REF <*D.30171, 8, 264>;
  D.30232 = D.30231 & 1;
  if (D.30232 != 0) goto <D.30233>; else goto <D.30234>;
  <D.30233>:
  D.30235 = BIT_FIELD_REF <*cfg, 8, 5624>;
  D.30236 = D.30235 & 2;
  if (D.30236 != 0) goto <D.30237>; else goto <D.30238>;
  <D.30237>:
  {
    struct MonoInst * lmf_var;

    D.30239 = mono_defaults.int_class;
    D.30240 = &D.30239->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.30240, 329);
    D.30241 = lmf_var->flags;
    D.30242 = D.30241 | 4;
    lmf_var->flags = D.30242;
    D.30241 = lmf_var->flags;
    D.30243 = D.30241 | 32;
    lmf_var->flags = D.30243;
    cfg->lmf_var = lmf_var;
  }
  <D.30238>:
  <D.30234>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.30244;
  unsigned char D.30247;
  unsigned char D.30248;
  struct MonoInst * D.30251;
  short unsigned int D.30254;
  short unsigned int D.30255;
  _Bool D.30256;
  short unsigned int D.30257;
  _Bool D.30258;
  _Bool D.30259;
  short unsigned int D.30262;
  short unsigned int D.30263;
  struct MonoMemPool * D.30272;
  long int D.30273;
  struct MonoInst * D.30274;
  int D.30275;
  int D.30276;
  const unsigned char * D.30277;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.26159>;
  <D.26158>:
  D.30244 = bb->next_bb;
  if (D.30244 != 0B) goto <D.30245>; else goto <D.30246>;
  <D.30245>:
  D.30244 = bb->next_bb;
  D.30247 = BIT_FIELD_REF <*D.30244, 8, 1488>;
  D.30248 = D.30247 & 1;
  if (D.30248 != 0) goto <D.30249>; else goto <D.30250>;
  <D.30249>:
  D.30251 = bb->last_ins;
  if (D.30251 != 0B) goto <D.30252>; else goto <D.30253>;
  <D.30252>:
  D.30251 = bb->last_ins;
  D.30254 = D.30251->opcode;
  D.30255 = D.30254 + 64981;
  D.30256 = D.30255 > 9;
  D.30257 = D.30254 + 64874;
  D.30258 = D.30257 > 9;
  D.30259 = D.30256 & D.30258;
  if (D.30259 != 0) goto <D.30260>; else goto <D.30261>;
  <D.30260>:
  D.30251 = bb->last_ins;
  D.30262 = D.30251->opcode;
  D.30263 = D.30262 + 64884;
  if (D.30263 > 9) goto <D.30264>; else goto <D.30265>;
  <D.30264>:
  D.30251 = bb->last_ins;
  D.30262 = D.30251->opcode;
  if (D.30262 != 446) goto <D.30266>; else goto <D.30267>;
  <D.30266>:
  D.30251 = bb->last_ins;
  D.30262 = D.30251->opcode;
  if (D.30262 != 763) goto <D.30268>; else goto <D.30269>;
  <D.30268>:
  D.30251 = bb->last_ins;
  D.30262 = D.30251->opcode;
  if (D.30262 != 370) goto <D.30270>; else goto <D.30271>;
  <D.30270>:
  {
    struct MonoInst * ins;

    D.30272 = cfg->mempool;
    ins = mono_mempool_alloc (D.30272, 80);
    ins->data.op[1].const_val = 0;
    D.30273 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30273;
    ins->prev = 0B;
    D.30274 = ins->prev;
    ins->next = D.30274;
    ins->opcode = 446;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30275 = ins->sreg3;
    ins->sreg2 = D.30275;
    D.30276 = ins->sreg2;
    ins->sreg1 = D.30276;
    D.30277 = cfg->ip;
    ins->cil_code = D.30277;
    D.30251 = bb->last_ins;
    if (D.30251 != 0B) goto <D.30278>; else goto <D.30279>;
    <D.30278>:
    D.30251 = bb->last_ins;
    D.30251->next = ins;
    D.30251 = bb->last_ins;
    ins->prev = D.30251;
    bb->last_ins = ins;
    goto <D.30280>;
    <D.30279>:
    bb->last_ins = ins;
    D.30251 = bb->last_ins;
    bb->code = D.30251;
    <D.30280>:
    D.30244 = bb->next_bb;
    ins->data.op[0].target_block = D.30244;
  }
  <D.30271>:
  <D.30269>:
  <D.30267>:
  <D.30265>:
  <D.30261>:
  <D.30253>:
  <D.30250>:
  <D.30246>:
  bb = bb->next_bb;
  <D.26159>:
  if (bb != 0B) goto <D.26158>; else goto <D.26160>;
  <D.26160>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.30281;
  unsigned int D.30282;
  unsigned int D.30285;
  struct MonoBasicBlock * * D.30286;
  long unsigned int D.30287;
  long unsigned int D.30288;
  struct MonoBasicBlock * * D.30289;
  struct MonoBasicBlock * D.30290;
  short int D.30291;
  int D.30292;
  int i;

  D.30281 = bb->flags;
  D.30282 = D.30281 & 1;
  if (D.30282 == 0) goto <D.30283>; else goto <D.30284>;
  <D.30283>:
  D.30281 = bb->flags;
  D.30285 = D.30281 | 1;
  bb->flags = D.30285;
  i = 0;
  goto <D.26151>;
  <D.26150>:
  D.30286 = bb->out_bb;
  D.30287 = (long unsigned int) i;
  D.30288 = D.30287 * 8;
  D.30289 = D.30286 + D.30288;
  D.30290 = *D.30289;
  compute_reachable (D.30290);
  i = i + 1;
  <D.26151>:
  D.30291 = bb->out_count;
  D.30292 = (int) D.30291;
  if (D.30292 > i) goto <D.26150>; else goto <D.26152>;
  <D.26152>:
  <D.30284>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30293;
  struct MonoBasicBlock * * D.30294;
  long unsigned int D.30295;
  long unsigned int D.30296;
  struct MonoBasicBlock * * D.30297;
  int D.30298;
  int D.30299;
  struct MonoBasicBlock * * D.30300;
  long unsigned int D.30301;
  long unsigned int D.30302;
  struct MonoBasicBlock * * D.30303;
  struct MonoBasicBlock * D.30304;
  int D.30305;
  short int D.30306;
  int D.30307;
  struct MonoBasicBlock * * D.30308;
  struct MonoBasicBlock * * D.30309;
  struct MonoBasicBlock * D.30310;
  int D.30311;
  short int D.30312;
  int D.30313;
  int iftmp.94;
  struct MonoBasicBlock * D.30315;
  struct MonoBitSet * D.30321;
  int D.30322;
  long unsigned int D.30323;
  long unsigned int D.30324;
  long unsigned int D.30325;
  int D.30326;
  long unsigned int D.30327;
  long unsigned int D.30328;
  _Bool D.30329;
  long int D.30330;
  long int D.30331;
  guint iftmp.95;
  struct MonoBitSet * D.30340;
  unsigned int i.96;
  unsigned int D.30344;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.30293 = cfg->method;
    method_name = mono_method_full_name (D.30293, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.25616>;
  <D.25615>:
  D.30294 = cfg->bblocks;
  D.30295 = (long unsigned int) i;
  D.30296 = D.30295 * 8;
  D.30297 = D.30294 + D.30296;
  bb = *D.30297;
  code = monoeg_strdup ("\n");
  D.30298 = bb->cil_length;
  D.30299 = bb->block_num;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.30299, i, D.30298, code);
  c = bb->code;
  goto <D.25607>;
  <D.25606>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.25607>:
  if (c != 0B) goto <D.25606>; else goto <D.25608>;
  <D.25608>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.25610>;
  <D.25609>:
  D.30300 = bb->in_bb;
  D.30301 = (long unsigned int) j;
  D.30302 = D.30301 * 8;
  D.30303 = D.30300 + D.30302;
  D.30304 = *D.30303;
  D.30305 = D.30304->block_num;
  monoeg_g_print (" BB%d", D.30305);
  j = j + 1;
  <D.25610>:
  D.30306 = bb->in_count;
  D.30307 = (int) D.30306;
  if (D.30307 > j) goto <D.25609>; else goto <D.25611>;
  <D.25611>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.25613>;
  <D.25612>:
  D.30308 = bb->out_bb;
  D.30301 = (long unsigned int) j;
  D.30302 = D.30301 * 8;
  D.30309 = D.30308 + D.30302;
  D.30310 = *D.30309;
  D.30311 = D.30310->block_num;
  monoeg_g_print (" BB%d", D.30311);
  j = j + 1;
  <D.25613>:
  D.30312 = bb->out_count;
  D.30313 = (int) D.30312;
  if (D.30313 > j) goto <D.25612>; else goto <D.25614>;
  <D.25614>:
  D.30315 = bb->idom;
  if (D.30315 != 0B) goto <D.30316>; else goto <D.30317>;
  <D.30316>:
  D.30315 = bb->idom;
  iftmp.94 = D.30315->block_num;
  goto <D.30318>;
  <D.30317>:
  iftmp.94 = -1;
  <D.30318>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.94);
  D.30315 = bb->idom;
  if (D.30315 != 0B) goto <D.30319>; else goto <D.30320>;
  <D.30319>:
  D.30321 = bb->dominators;
  D.30315 = bb->idom;
  D.30322 = D.30315->dfn;
  D.30323 = (long unsigned int) D.30322;
  D.30324 = D.30323 / 64;
  D.30325 = D.30321->data[D.30324];
  D.30315 = bb->idom;
  D.30322 = D.30315->dfn;
  D.30326 = D.30322 & 63;
  D.30327 = D.30325 >> D.30326;
  D.30328 = D.30327 & 1;
  D.30329 = D.30328 == 0;
  D.30330 = (long int) D.30329;
  D.30331 = __builtin_expect (D.30330, 0);
  if (D.30331 != 0) goto <D.30332>; else goto <D.30333>;
  <D.30332>:
  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.30333>:
  <D.30320>:
  D.30321 = bb->dominators;
  if (D.30321 != 0B) goto <D.30334>; else goto <D.30335>;
  <D.30334>:
  D.30315 = bb->idom;
  if (D.30315 != 0B) goto <D.30337>; else goto <D.30338>;
  <D.30337>:
  D.30315 = bb->idom;
  D.30322 = D.30315->dfn;
  iftmp.95 = (guint) D.30322;
  goto <D.30339>;
  <D.30338>:
  iftmp.95 = 4294967295;
  <D.30339>:
  D.30321 = bb->dominators;
  mono_blockset_print (cfg, D.30321, "\tdominators", iftmp.95);
  <D.30335>:
  D.30340 = bb->dfrontier;
  if (D.30340 != 0B) goto <D.30341>; else goto <D.30342>;
  <D.30341>:
  D.30340 = bb->dfrontier;
  mono_blockset_print (cfg, D.30340, "\tdfrontier", 4294967295);
  <D.30342>:
  monoeg_g_free (code);
  i = i + 1;
  <D.25616>:
  i.96 = (unsigned int) i;
  D.30344 = cfg->num_bblocks;
  if (i.96 < D.30344) goto <D.25615>; else goto <D.25617>;
  <D.25617>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.30345;
  long unsigned int D.30346;
  long unsigned int D.30347;
  struct MonoBasicBlock * * D.30348;
  struct MonoBasicBlock * * D.30349;
  long unsigned int D.30350;
  long unsigned int D.30351;
  struct MonoBasicBlock * * D.30352;
  struct MonoBasicBlock * D.30353;
  int D.30354;
  int D.30357;
  short int D.30358;
  int D.30359;
  int i;

  D.30345 = *dfn;
  D.30346 = (long unsigned int) D.30345;
  D.30347 = D.30346 * 8;
  D.30348 = array + D.30347;
  *D.30348 = start;
  i = 0;
  goto <D.25110>;
  <D.25109>:
  D.30349 = start->out_bb;
  D.30350 = (long unsigned int) i;
  D.30351 = D.30350 * 8;
  D.30352 = D.30349 + D.30351;
  D.30353 = *D.30352;
  D.30354 = D.30353->dfn;
  if (D.30354 != 0) goto <D.30355>; else goto <D.30356>;
  <D.30355>:
  // predicted unlikely by continue predictor.
  goto <D.25108>;
  <D.30356>:
  D.30345 = *dfn;
  D.30357 = D.30345 + 1;
  *dfn = D.30357;
  D.30349 = start->out_bb;
  D.30350 = (long unsigned int) i;
  D.30351 = D.30350 * 8;
  D.30352 = D.30349 + D.30351;
  D.30353 = *D.30352;
  D.30345 = *dfn;
  D.30353->dfn = D.30345;
  D.30349 = start->out_bb;
  D.30350 = (long unsigned int) i;
  D.30351 = D.30350 * 8;
  D.30352 = D.30349 + D.30351;
  D.30353 = *D.30352;
  D.30353->df_parent = start;
  D.30345 = *dfn;
  D.30346 = (long unsigned int) D.30345;
  D.30347 = D.30346 * 8;
  D.30348 = array + D.30347;
  D.30349 = start->out_bb;
  D.30350 = (long unsigned int) i;
  D.30351 = D.30350 * 8;
  D.30352 = D.30349 + D.30351;
  D.30353 = *D.30352;
  *D.30348 = D.30353;
  D.30349 = start->out_bb;
  D.30350 = (long unsigned int) i;
  D.30351 = D.30350 * 8;
  D.30352 = D.30349 + D.30351;
  D.30353 = *D.30352;
  df_visit (D.30353, dfn, array);
  <D.25108>:
  i = i + 1;
  <D.25110>:
  D.30358 = start->out_count;
  D.30359 = (int) D.30358;
  if (D.30359 > i) goto <D.25109>; else goto <D.25111>;
  <D.25111>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30360;
  unsigned int D.30361;

  D.30361 = __sync_add_and_fetch_4 (val, 1);
  D.30360 = (gint32) D.30361;
  return D.30360;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.30363;
  _Bool D.30364;
  long int D.30365;
  long int D.30366;
  struct MonoGenericSharingContext * D.30369;
  unsigned char D.30373;
  unsigned char D.30374;
  struct MonoMethod * D.30377;
  short unsigned int D.30378;
  int D.30379;
  int D.30380;
  long unsigned int D.30381;
  long unsigned int D.30382;
  int D.30383;
  struct GSList * D.30386;
  struct MonoBasicBlock * D.30389;
  int D.30390;
  int D.30391;
  struct MonoBasicBlock * * D.30392;
  unsigned int D.30393;
  unsigned int D.30394;
  unsigned int D.30395;
  long unsigned int D.30396;
  long unsigned int D.30397;
  struct MonoBasicBlock * * D.30398;
  _Bool D.30399;
  long int D.30400;
  long int D.30401;
  int D.30404;
  long unsigned int D.30409;
  unsigned int D.30410;
  unsigned int D.30411;
  unsigned int D.30412;
  unsigned int D.30413;
  _Bool D.30414;
  long int D.30415;
  long int D.30416;
  unsigned char D.30419;
  unsigned int D.30424;
  <unnamed-unsigned:15> D.30426;
  unsigned char D.30427;
  unsigned char D.30428;
  long unsigned int D.30431;
  long unsigned int D.30432;
  long unsigned int D.30433;
  long unsigned int D.30434;
  long unsigned int D.30435;
  long unsigned int D.30436;
  long unsigned int D.30437;
  long unsigned int D.30438;
  long unsigned int D.30439;
  long unsigned int D.30440;
  long unsigned int D.30441;
  unsigned int D.30443;
  unsigned int D.30444;
  unsigned int generic_info_size.97;
  unsigned int D.30446;
  unsigned int holes_size.98;
  unsigned int D.30448;
  unsigned int arch_eh_info_size.99;
  unsigned int D.30450;
  unsigned int cas_size.100;
  unsigned int D.30452;
  unsigned int D.30453;
  struct MonoDomain * D.30454;
  unsigned char * D.30455;
  unsigned int D.30456;
  int D.30457;
  long unsigned int D.30458;
  unsigned int D.30459;
  unsigned int D.30460;
  unsigned int D.30461;
  _Bool D.30462;
  <unnamed-signed:1> D.30463;
  short unsigned int D.30464;
  <unnamed-unsigned:15> D.30465;
  _Bool D.30470;
  long int D.30471;
  long int D.30472;
  void * D.30477;
  void * D.30479;
  struct MonoGenericSharingContext * D.30480;
  short unsigned int D.30483;
  int D.30484;
  int D.30485;
  struct MonoGenericContext * D.30487;
  struct MonoGenericInst * D.30488;
  struct MonoClass * D.30490;
  unsigned char D.30491;
  unsigned char D.30492;
  struct MonoInst * D.30493;
  _Bool D.30494;
  long int D.30495;
  long int D.30496;
  struct MonoGenericContext * D.30503;
  struct MonoGenericInst * D.30504;
  short unsigned int D.30508;
  _Bool D.30509;
  long int D.30510;
  long int D.30511;
  struct MonoInst * * D.30514;
  unsigned int D.30517;
  int D.30518;
  int D.30521;
  long unsigned int D.30522;
  long unsigned int D.30523;
  void * D.30524;
  unsigned int D.30526;
  unsigned int D.30527;
  void * D.30528;
  void * D.30529;
  struct MonoDwarfLocListEntry * D.30530;
  long unsigned int D.30531;
  long unsigned int D.30532;
  struct MonoDwarfLocListEntry * D.30533;
  int D.30536;
  _Bool D.30537;
  long int D.30538;
  long int D.30539;
  unsigned char D.30542;
  int D.30543;
  int D.30547;
  unsigned char D.30548;
  int D.30552;
  unsigned int D.30553;
  unsigned int D.30554;
  _Bool D.30555;
  long int D.30556;
  long int D.30557;
  long int D.30560;
  unsigned long D.30561;
  unsigned long D.30562;
  _Bool D.30563;
  long int D.30564;
  long int D.30565;
  unsigned char D.30568;
  int D.30569;
  short unsigned int D.30572;
  struct MonoBasicBlock * D.30573;
  int D.30574;
  int D.30575;
  unsigned int D.30576;
  unsigned int D.30577;
  unsigned int D.30578;
  long unsigned int D.30579;
  long unsigned int D.30580;
  struct MonoBasicBlock * * D.30581;
  _Bool D.30582;
  long int D.30583;
  long int D.30584;
  int D.30587;
  int D.30590;
  int D.30591;
  int i.101;
  struct MonoExceptionClause * D.30593;
  long int D.30594;
  struct MonoExceptionClause * D.30595;
  long int D.30596;
  long int D.30597;
  long int D.30598;
  short unsigned int D.30599;
  unsigned int D.30600;
  short unsigned int D.30601;
  short unsigned int D.30602;
  short unsigned int D.30603;
  short unsigned int D.30606;
  int D.30607;
  unsigned int D.30608;
  short unsigned int D.30609;
  int D.30610;
  _Bool D.30611;
  long int D.30612;
  long int D.30613;
  struct MonoJitExceptionInfo * D.30624;
  struct MonoJitExceptionInfo * D.30625;
  short unsigned int D.30627;
  short unsigned int D.30628;
  long unsigned int D.30631;
  long unsigned int D.30632;
  unsigned int D.30633;
  unsigned int D.30634;
  int D.30635;
  gint32 iftmp.102;
  long int D.30639;
  unsigned int D.30641;
  unsigned int D.30644;
  long unsigned int D.30645;
  long unsigned int D.30646;
  struct MonoBasicBlock * * D.30647;
  _Bool D.30648;
  long int D.30649;
  long int D.30650;
  int D.30653;
  sizetype D.30654;
  void * D.30655;
  struct MonoClass * D.30657;
  unsigned int D.30658;
  long unsigned int D.30659;
  long unsigned int D.30660;
  struct MonoBasicBlock * * D.30661;
  _Bool D.30664;
  long int D.30665;
  long int D.30666;
  unsigned char D.30669;
  unsigned char D.30670;
  void * D.30673;
  void * D.30674;
  unsigned int D.30675;
  unsigned int D.30676;
  long unsigned int D.30677;
  long unsigned int D.30678;
  struct MonoBasicBlock * * D.30679;
  long unsigned int D.30684;
  long unsigned int D.30685;
  struct MonoBasicBlock * * D.30686;
  int D.30689;
  long unsigned int D.30694;
  long unsigned int D.30695;
  struct MonoBasicBlock * * D.30696;
  struct MonoBasicBlock * D.30699;
  int D.30700;
  int D.30701;
  int D.30702;
  sizetype D.30703;
  struct MonoExceptionClause * D.30704;
  void * D.30707;
  int D.30712;
  long int D.30713;
  long int D.30714;
  long int D.30715;
  int D.30716;
  sizetype D.30717;
  void * D.30718;
  unsigned int D.30721;
  unsigned int D.30722;
  unsigned int D.30723;
  long unsigned int D.30726;
  long unsigned int D.30727;
  struct MonoBasicBlock * * D.30728;
  long unsigned int D.30732;
  long unsigned int D.30733;
  struct MonoBasicBlock * * D.30734;
  int D.30737;
  int D.30740;
  unsigned int D.30742;
  sizetype D.30743;
  void * D.30744;
  int D.30745;
  void * D.30748;
  long int D.30749;
  long int D.30750;
  void * D.30751;
  long int D.30752;
  long int D.30753;
  void * D.30754;
  long int D.30755;
  long int D.30756;
  void * D.30757;
  long int D.30758;
  long int D.30759;
  unsigned int D.30760;
  <unnamed-unsigned:15> D.30761;
  int D.30762;
  guint8 * D.30763;
  unsigned int D.30766;
  unsigned int D.30767;
  struct GSList * D.30769;
  unsigned int info_len.103;
  unsigned int D.30773;
  struct MonoJitInfo * D.30774;
  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.30363 = cfg->method;
  D.30364 = D.30363 != method_to_compile;
  D.30365 = (long int) D.30364;
  D.30366 = __builtin_expect (D.30365, 0);
  if (D.30366 != 0) goto <D.30367>; else goto <D.30368>;
  <D.30367>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.30368>:
  header = cfg->header;
  D.30369 = cfg->generic_sharing_context;
  if (D.30369 != 0B) goto <D.30370>; else goto <D.30371>;
  <D.30370>:
  generic_info_size = 32;
  goto <D.30372>;
  <D.30371>:
  generic_info_size = 0;
  <D.30372>:
  D.30373 = BIT_FIELD_REF <*cfg, 8, 5640>;
  D.30374 = D.30373 & 2;
  if (D.30374 != 0) goto <D.30375>; else goto <D.30376>;
  <D.30375>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.30377 = cfg->method_to_register;
    sig = mono_method_signature (D.30377);
    D.30378 = sig->param_count;
    D.30379 = (int) D.30378;
    D.30380 = D.30379 + 1;
    D.30381 = (long unsigned int) D.30380;
    D.30382 = D.30381 * 6;
    arg_info = __builtin_alloca (D.30382);
    D.30378 = sig->param_count;
    D.30379 = (int) D.30378;
    D.30369 = cfg->generic_sharing_context;
    D.30383 = mono_arch_get_argument_info (D.30369, sig, D.30379, arg_info);
    stack_size = (guint32) D.30383;
    if (stack_size != 0) goto <D.30384>; else goto <D.30385>;
    <D.30384>:
    arch_eh_info_size = 4;
    <D.30385>:
  }
  <D.30376>:
  D.30386 = cfg->try_block_holes;
  if (D.30386 != 0B) goto <D.30387>; else goto <D.30388>;
  <D.30387>:
  tmp = cfg->try_block_holes;
  goto <D.26190>;
  <D.26189>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.30389 = hole->basic_block;
    D.30390 = D.30389->native_offset;
    D.30389 = hole->basic_block;
    D.30391 = D.30389->native_length;
    hole_end = D.30390 + D.30391;
    D.30392 = cfg->cil_offset_to_bb;
    D.30393 = ec->try_offset;
    D.30394 = ec->try_len;
    D.30395 = D.30393 + D.30394;
    D.30396 = (long unsigned int) D.30395;
    D.30397 = D.30396 * 8;
    D.30398 = D.30392 + D.30397;
    clause_last_bb = *D.30398;
    D.30399 = clause_last_bb == 0B;
    D.30400 = (long int) D.30399;
    D.30401 = __builtin_expect (D.30400, 0);
    if (D.30401 != 0) goto <D.30402>; else goto <D.30403>;
    <D.30402>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.30403>:
    D.30404 = clause_last_bb->native_offset;
    if (D.30404 != hole_end) goto <D.30405>; else goto <D.30406>;
    <D.30405>:
    num_holes = num_holes + 1;
    <D.30406>:
  }
  tmp = tmp->next;
  <D.26190>:
  if (tmp != 0B) goto <D.26189>; else goto <D.26191>;
  <D.26191>:
  if (num_holes != 0) goto <D.30407>; else goto <D.30408>;
  <D.30407>:
  D.30409 = (long unsigned int) num_holes;
  D.30410 = (unsigned int) D.30409;
  D.30411 = D.30410 * 8;
  D.30412 = D.30411 + 4;
  holes_size = (int) D.30412;
  <D.30408>:
  D.30413 = cfg->verbose_level;
  D.30414 = D.30413 > 3;
  D.30415 = (long int) D.30414;
  D.30416 = __builtin_expect (D.30415, 0);
  if (D.30416 != 0) goto <D.30417>; else goto <D.30418>;
  <D.30417>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.30418>:
  <D.30388>:
  D.30377 = cfg->method_to_register;
  D.30419 = mono_method_has_declsec (D.30377);
  if (D.30419 != 0) goto <D.30420>; else goto <D.30421>;
  <D.30420>:
  cas_size = 4;
  <D.30421>:
  if (0 != 0) goto <D.30422>; else goto <D.30423>;
  <D.30422>:
  D.30424 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.30424;
  goto <D.30425>;
  <D.30423>:
  D.30426 = header->num_clauses;
  num_clauses = (int) D.30426;
  <D.30425>:
  D.30363 = cfg->method;
  D.30427 = BIT_FIELD_REF <*D.30363, 8, 264>;
  D.30428 = D.30427 & 2;
  if (D.30428 != 0) goto <D.30429>; else goto <D.30430>;
  <D.30429>:
  D.30431 = (long unsigned int) num_clauses;
  D.30432 = D.30431 * 40;
  D.30433 = (long unsigned int) generic_info_size;
  D.30434 = D.30432 + D.30433;
  D.30435 = (long unsigned int) holes_size;
  D.30436 = D.30434 + D.30435;
  D.30437 = (long unsigned int) arch_eh_info_size;
  D.30438 = D.30436 + D.30437;
  D.30439 = (long unsigned int) cas_size;
  D.30440 = D.30438 + D.30439;
  D.30441 = D.30440 + 48;
  jinfo = monoeg_malloc0 (D.30441);
  goto <D.30442>;
  <D.30430>:
  D.30431 = (long unsigned int) num_clauses;
  D.30443 = (unsigned int) D.30431;
  D.30444 = D.30443 * 40;
  generic_info_size.97 = (unsigned int) generic_info_size;
  D.30446 = D.30444 + generic_info_size.97;
  holes_size.98 = (unsigned int) holes_size;
  D.30448 = D.30446 + holes_size.98;
  arch_eh_info_size.99 = (unsigned int) arch_eh_info_size;
  D.30450 = D.30448 + arch_eh_info_size.99;
  cas_size.100 = (unsigned int) cas_size;
  D.30452 = D.30450 + cas_size.100;
  D.30453 = D.30452 + 48;
  D.30454 = cfg->domain;
  jinfo = mono_domain_alloc0 (D.30454, D.30453);
  <D.30442>:
  D.30377 = cfg->method_to_register;
  jinfo->d.method = D.30377;
  D.30455 = cfg->native_code;
  jinfo->code_start = D.30455;
  D.30456 = cfg->code_len;
  D.30457 = (int) D.30456;
  jinfo->code_size = D.30457;
  D.30458 = cfg->used_int_regs;
  D.30459 = (unsigned int) D.30458;
  jinfo->used_regs = D.30459;
  D.30460 = cfg->opt;
  D.30461 = D.30460 & 512;
  D.30462 = D.30461 != 0;
  D.30463 = (<unnamed-signed:1>) D.30462;
  jinfo->domain_neutral = D.30463;
  D.30464 = (short unsigned int) num_clauses;
  D.30465 = (<unnamed-unsigned:15>) D.30464;
  jinfo->num_clauses = D.30465;
  if (0 != 0) goto <D.30466>; else goto <D.30467>;
  <D.30466>:
  jinfo->from_llvm = -1;
  <D.30467>:
  D.30369 = cfg->generic_sharing_context;
  if (D.30369 != 0B) goto <D.30468>; else goto <D.30469>;
  <D.30468>:
  {
    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.30470 = gi == 0B;
    D.30471 = (long int) D.30470;
    D.30472 = __builtin_expect (D.30471, 0);
    if (D.30472 != 0) goto <D.30473>; else goto <D.30474>;
    <D.30473>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.30474>:
    D.30363 = cfg->method;
    D.30427 = BIT_FIELD_REF <*D.30363, 8, 264>;
    D.30428 = D.30427 & 2;
    if (D.30428 != 0) goto <D.30475>; else goto <D.30476>;
    <D.30475>:
    D.30477 = monoeg_malloc0 (16);
    gi->generic_sharing_context = D.30477;
    goto <D.30478>;
    <D.30476>:
    D.30454 = cfg->domain;
    D.30479 = mono_domain_alloc0 (D.30454, 16);
    gi->generic_sharing_context = D.30479;
    <D.30478>:
    D.30369 = cfg->generic_sharing_context;
    D.30480 = gi->generic_sharing_context;
    memcpy (D.30480, D.30369, 16);
    D.30483 = method_to_compile->flags;
    D.30484 = (int) D.30483;
    D.30485 = D.30484 & 16;
    if (D.30485 != 0) goto <D.30481>; else goto <D.30486>;
    <D.30486>:
    D.30487 = mini_method_get_context (method_to_compile);
    D.30488 = D.30487->method_inst;
    if (D.30488 != 0B) goto <D.30481>; else goto <D.30489>;
    <D.30489>:
    D.30490 = method_to_compile->klass;
    D.30491 = BIT_FIELD_REF <*D.30490, 8, 256>;
    D.30492 = D.30491 & 8;
    if (D.30492 != 0) goto <D.30481>; else goto <D.30482>;
    <D.30481>:
    D.30493 = cfg->rgctx_var;
    D.30494 = D.30493 == 0B;
    D.30495 = (long int) D.30494;
    D.30496 = __builtin_expect (D.30495, 0);
    if (D.30496 != 0) goto <D.30497>; else goto <D.30498>;
    <D.30497>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.30498>:
    <D.30482>:
    gi->has_this = -1;
    D.30483 = method_to_compile->flags;
    D.30484 = (int) D.30483;
    D.30485 = D.30484 & 16;
    if (D.30485 != 0) goto <D.30499>; else goto <D.30502>;
    <D.30502>:
    D.30503 = mini_method_get_context (method_to_compile);
    D.30504 = D.30503->method_inst;
    if (D.30504 != 0B) goto <D.30499>; else goto <D.30505>;
    <D.30505>:
    D.30490 = method_to_compile->klass;
    D.30491 = BIT_FIELD_REF <*D.30490, 8, 256>;
    D.30492 = D.30491 & 8;
    if (D.30492 != 0) goto <D.30499>; else goto <D.30500>;
    <D.30499>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.30506>; else goto <D.30507>;
    <D.30506>:
    D.30508 = inst->opcode;
    D.30509 = D.30508 != 367;
    D.30510 = (long int) D.30509;
    D.30511 = __builtin_expect (D.30510, 0);
    if (D.30511 != 0) goto <D.30512>; else goto <D.30513>;
    <D.30512>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4378, "inst->opcode == OP_REGOFFSET");
    <D.30513>:
    <D.30507>:
    loclist = cfg->rgctx_loclist;
    goto <D.30501>;
    <D.30500>:
    D.30514 = cfg->args;
    inst = *D.30514;
    loclist = cfg->this_loclist;
    <D.30501>:
    if (loclist != 0B) goto <D.30515>; else goto <D.30516>;
    <D.30515>:
    {
      struct GSList * l;
      int i;

      D.30517 = monoeg_g_slist_length (loclist);
      D.30518 = (int) D.30517;
      gi->nlocs = D.30518;
      D.30363 = cfg->method;
      D.30427 = BIT_FIELD_REF <*D.30363, 8, 264>;
      D.30428 = D.30427 & 2;
      if (D.30428 != 0) goto <D.30519>; else goto <D.30520>;
      <D.30519>:
      D.30521 = gi->nlocs;
      D.30522 = (long unsigned int) D.30521;
      D.30523 = D.30522 * 20;
      D.30524 = monoeg_malloc0 (D.30523);
      gi->locations = D.30524;
      goto <D.30525>;
      <D.30520>:
      D.30521 = gi->nlocs;
      D.30522 = (long unsigned int) D.30521;
      D.30526 = (unsigned int) D.30522;
      D.30527 = D.30526 * 20;
      D.30454 = cfg->domain;
      D.30528 = mono_domain_alloc0 (D.30454, D.30527);
      gi->locations = D.30528;
      <D.30525>:
      i = 0;
      l = loclist;
      goto <D.26198>;
      <D.26197>:
      D.30529 = l->data;
      D.30530 = gi->locations;
      D.30531 = (long unsigned int) i;
      D.30532 = D.30531 * 20;
      D.30533 = D.30530 + D.30532;
      memcpy (D.30533, D.30529, 20);
      i = i + 1;
      l = l->next;
      <D.26198>:
      if (l != 0B) goto <D.26197>; else goto <D.26199>;
      <D.26199>:
    }
    <D.30516>:
    if (0 != 0) goto <D.30534>; else goto <D.30535>;
    <D.30534>:
    D.30536 = cfg->llvm_this_reg;
    D.30537 = D.30536 == -1;
    D.30538 = (long int) D.30537;
    D.30539 = __builtin_expect (D.30538, 0);
    if (D.30539 != 0) goto <D.30540>; else goto <D.30541>;
    <D.30540>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.30541>:
    gi->this_in_reg = 0;
    D.30536 = cfg->llvm_this_reg;
    D.30542 = (unsigned char) D.30536;
    gi->this_reg = D.30542;
    D.30543 = cfg->llvm_this_offset;
    gi->this_offset = D.30543;
    goto <D.30544>;
    <D.30535>:
    D.30508 = inst->opcode;
    if (D.30508 == 366) goto <D.30545>; else goto <D.30546>;
    <D.30545>:
    gi->this_in_reg = -1;
    D.30547 = inst->dreg;
    D.30548 = (unsigned char) D.30547;
    gi->this_reg = D.30548;
    goto <D.30549>;
    <D.30546>:
    D.30508 = inst->opcode;
    D.30509 = D.30508 != 367;
    D.30510 = (long int) D.30509;
    D.30511 = __builtin_expect (D.30510, 0);
    if (D.30511 != 0) goto <D.30550>; else goto <D.30551>;
    <D.30550>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.30551>:
    D.30552 = inst->sreg1;
    D.30553 = (unsigned int) D.30552;
    D.30554 = D.30553 + 4294967292;
    D.30555 = D.30554 > 1;
    D.30556 = (long int) D.30555;
    D.30557 = __builtin_expect (D.30556, 0);
    if (D.30557 != 0) goto <D.30558>; else goto <D.30559>;
    <D.30558>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4415, "inst->inst_basereg == X86_EBP || inst->inst_basereg == X86_ESP");
    <D.30559>:
    D.30560 = inst->data.op[0].const_val;
    D.30561 = (unsigned long) D.30560;
    D.30562 = D.30561 + 2147483648;
    D.30563 = D.30562 > 4294967295;
    D.30564 = (long int) D.30563;
    D.30565 = __builtin_expect (D.30564, 0);
    if (D.30565 != 0) goto <D.30566>; else goto <D.30567>;
    <D.30566>:
    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.30567>:
    gi->this_in_reg = 0;
    D.30552 = inst->sreg1;
    D.30568 = (unsigned char) D.30552;
    gi->this_reg = D.30568;
    D.30560 = inst->data.op[0].const_val;
    D.30569 = (int) D.30560;
    gi->this_offset = D.30569;
    <D.30549>:
    <D.30544>:
  }
  <D.30469>:
  if (num_holes != 0) goto <D.30570>; else goto <D.30571>;
  <D.30570>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.30572 = (short unsigned int) num_holes;
    table->num_holes = D.30572;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.26210>;
    <D.26209>:
    {
      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.30573 = hole_data->basic_block;
      D.30574 = D.30573->native_offset;
      D.30573 = hole_data->basic_block;
      D.30575 = D.30573->native_length;
      hole_end = D.30574 + D.30575;
      D.30392 = cfg->cil_offset_to_bb;
      D.30576 = ec->try_offset;
      D.30577 = ec->try_len;
      D.30578 = D.30576 + D.30577;
      D.30579 = (long unsigned int) D.30578;
      D.30580 = D.30579 * 8;
      D.30581 = D.30392 + D.30580;
      clause_last_bb = *D.30581;
      D.30582 = clause_last_bb == 0B;
      D.30583 = (long int) D.30582;
      D.30584 = __builtin_expect (D.30583, 0);
      if (D.30584 != 0) goto <D.30585>; else goto <D.30586>;
      <D.30585>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.30586>:
      D.30587 = clause_last_bb->native_offset;
      if (D.30587 == hole_end) goto <D.30588>; else goto <D.30589>;
      <D.30588>:
      // predicted unlikely by continue predictor.
      goto <D.26208>;
      <D.30589>:
      D.30590 = hole_data->start_offset;
      D.30573 = hole_data->basic_block;
      D.30574 = D.30573->native_offset;
      D.30591 = D.30590 - D.30574;
      start_bb_offset = (guint32) D.30591;
      i.101 = i;
      i = i.101 + 1;
      hole = &table->holes[i.101];
      D.30593 = hole_data->clause;
      D.30594 = (long int) D.30593;
      D.30595 = header->clauses;
      D.30596 = (long int) D.30595;
      D.30597 = D.30594 - D.30596;
      D.30598 = D.30597 /[ex] 32;
      D.30599 = (short unsigned int) D.30598;
      hole->clause = D.30599;
      D.30590 = hole_data->start_offset;
      D.30600 = (unsigned int) D.30590;
      hole->offset = D.30600;
      D.30573 = hole_data->basic_block;
      D.30575 = D.30573->native_length;
      D.30601 = (short unsigned int) D.30575;
      D.30602 = (short unsigned int) start_bb_offset;
      D.30603 = D.30601 - D.30602;
      hole->length = D.30603;
      D.30413 = cfg->verbose_level;
      D.30414 = D.30413 > 3;
      D.30415 = (long int) D.30414;
      D.30416 = __builtin_expect (D.30415, 0);
      if (D.30416 != 0) goto <D.30604>; else goto <D.30605>;
      <D.30604>:
      D.30606 = hole->length;
      D.30607 = (int) D.30606;
      D.30608 = hole->offset;
      D.30609 = hole->clause;
      D.30610 = (int) D.30609;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.30610, D.30608, D.30607);
      <D.30605>:
    }
    <D.26208>:
    tmp = tmp->next;
    <D.26210>:
    if (tmp != 0B) goto <D.26209>; else goto <D.26211>;
    <D.26211>:
    D.30611 = i != num_holes;
    D.30612 = (long int) D.30611;
    D.30613 = __builtin_expect (D.30612, 0);
    if (D.30613 != 0) goto <D.30614>; else goto <D.30615>;
    <D.30614>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.30615>:
  }
  <D.30571>:
  if (arch_eh_info_size != 0) goto <D.30616>; else goto <D.30617>;
  <D.30616>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.30617>:
  if (cas_size != 0) goto <D.30618>; else goto <D.30619>;
  <D.30618>:
  jinfo->has_cas_info = -1;
  <D.30619>:
  if (0 != 0) goto <D.30620>; else goto <D.30621>;
  <D.30620>:
  if (num_clauses != 0) goto <D.30622>; else goto <D.30623>;
  <D.30622>:
  D.30431 = (long unsigned int) num_clauses;
  D.30432 = D.30431 * 40;
  D.30624 = cfg->llvm_ex_info;
  D.30625 = &jinfo->clauses[0];
  memcpy (D.30625, D.30624, D.30432);
  <D.30623>:
  goto <D.30626>;
  <D.30621>:
  D.30627 = BIT_FIELD_REF <*header, 16, 112>;
  D.30628 = D.30627 & 32767;
  if (D.30628 != 0) goto <D.30629>; else goto <D.30630>;
  <D.30629>:
  {
    int i;

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

      D.30595 = header->clauses;
      D.30631 = (long unsigned int) i;
      D.30632 = D.30631 * 32;
      ec = D.30595 + D.30632;
      ei = &jinfo->clauses[i];
      D.30633 = ec->flags;
      ei->flags = D.30633;
      D.30634 = ec->handler_offset;
      D.30635 = (int) D.30634;
      exvar = mono_find_exvar_for_offset (cfg, D.30635);
      if (exvar != 0B) goto <D.30637>; else goto <D.30638>;
      <D.30637>:
      D.30639 = exvar->data.op[0].const_val;
      iftmp.102 = (gint32) D.30639;
      goto <D.30640>;
      <D.30638>:
      iftmp.102 = 0;
      <D.30640>:
      ei->exvar_offset = iftmp.102;
      D.30641 = ei->flags;
      if (D.30641 == 1) goto <D.30642>; else goto <D.30643>;
      <D.30642>:
      D.30392 = cfg->cil_offset_to_bb;
      D.30644 = ec->data.filter_offset;
      D.30645 = (long unsigned int) D.30644;
      D.30646 = D.30645 * 8;
      D.30647 = D.30392 + D.30646;
      tblock = *D.30647;
      D.30648 = tblock == 0B;
      D.30649 = (long int) D.30648;
      D.30650 = __builtin_expect (D.30649, 0);
      if (D.30650 != 0) goto <D.30651>; else goto <D.30652>;
      <D.30651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.30652>:
      D.30455 = cfg->native_code;
      D.30653 = tblock->native_offset;
      D.30654 = (sizetype) D.30653;
      D.30655 = D.30455 + D.30654;
      ei->data.filter = D.30655;
      goto <D.30656>;
      <D.30643>:
      D.30657 = ec->data.catch_class;
      ei->data.catch_class = D.30657;
      <D.30656>:
      D.30392 = cfg->cil_offset_to_bb;
      D.30658 = ec->try_offset;
      D.30659 = (long unsigned int) D.30658;
      D.30660 = D.30659 * 8;
      D.30661 = D.30392 + D.30660;
      tblock = *D.30661;
      D.30648 = tblock == 0B;
      D.30649 = (long int) D.30648;
      D.30650 = __builtin_expect (D.30649, 0);
      if (D.30650 != 0) goto <D.30662>; else goto <D.30663>;
      <D.30662>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.30663>:
      D.30653 = tblock->native_offset;
      D.30664 = D.30653 == 0;
      D.30665 = (long int) D.30664;
      D.30666 = __builtin_expect (D.30665, 0);
      if (D.30666 != 0) goto <D.30667>; else goto <D.30668>;
      <D.30667>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.30668>:
      D.30455 = cfg->native_code;
      D.30653 = tblock->native_offset;
      D.30654 = (sizetype) D.30653;
      D.30655 = D.30455 + D.30654;
      ei->try_start = D.30655;
      D.30669 = BIT_FIELD_REF <*tblock, 8, 1488>;
      D.30670 = D.30669 & 128;
      if (D.30670 != 0) goto <D.30671>; else goto <D.30672>;
      <D.30671>:
      D.30673 = ei->try_start;
      D.30674 = D.30673 + 18446744073709551615;
      ei->try_start = D.30674;
      <D.30672>:
      D.30392 = cfg->cil_offset_to_bb;
      D.30658 = ec->try_offset;
      D.30675 = ec->try_len;
      D.30676 = D.30658 + D.30675;
      D.30677 = (long unsigned int) D.30676;
      D.30678 = D.30677 * 8;
      D.30679 = D.30392 + D.30678;
      tblock = *D.30679;
      D.30648 = tblock == 0B;
      D.30649 = (long int) D.30648;
      D.30650 = __builtin_expect (D.30649, 0);
      if (D.30650 != 0) goto <D.30680>; else goto <D.30681>;
      <D.30680>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.30681>:
      D.30653 = tblock->native_offset;
      if (D.30653 == 0) goto <D.30682>; else goto <D.30683>;
      <D.30682>:
      {
        int j;
        int end;

        D.30658 = ec->try_offset;
        D.30675 = ec->try_len;
        D.30676 = D.30658 + D.30675;
        j = (int) D.30676;
        D.30658 = ec->try_offset;
        end = (int) D.30658;
        goto <D.26223>;
        <D.26222>:
        {
          struct MonoBasicBlock * bb;

          D.30392 = cfg->cil_offset_to_bb;
          D.30684 = (long unsigned int) j;
          D.30685 = D.30684 * 8;
          D.30686 = D.30392 + D.30685;
          bb = *D.30686;
          if (bb != 0B) goto <D.30687>; else goto <D.30688>;
          <D.30687>:
          D.30689 = bb->native_offset;
          if (D.30689 != 0) goto <D.30690>; else goto <D.30691>;
          <D.30690>:
          tblock = bb;
          goto <D.26221>;
          <D.30691>:
          <D.30688>:
        }
        j = j + -1;
        <D.26223>:
        if (j >= end) goto <D.26222>; else goto <D.26221>;
        <D.26221>:
      }
      <D.30683>:
      D.30455 = cfg->native_code;
      D.30653 = tblock->native_offset;
      D.30654 = (sizetype) D.30653;
      D.30655 = D.30455 + D.30654;
      ei->try_end = D.30655;
      D.30653 = tblock->native_offset;
      D.30664 = D.30653 == 0;
      D.30665 = (long int) D.30664;
      D.30666 = __builtin_expect (D.30665, 0);
      if (D.30666 != 0) goto <D.30692>; else goto <D.30693>;
      <D.30692>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.30693>:
      D.30392 = cfg->cil_offset_to_bb;
      D.30634 = ec->handler_offset;
      D.30694 = (long unsigned int) D.30634;
      D.30695 = D.30694 * 8;
      D.30696 = D.30392 + D.30695;
      tblock = *D.30696;
      D.30648 = tblock == 0B;
      D.30649 = (long int) D.30648;
      D.30650 = __builtin_expect (D.30649, 0);
      if (D.30650 != 0) goto <D.30697>; else goto <D.30698>;
      <D.30697>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.30698>:
      D.30455 = cfg->native_code;
      D.30653 = tblock->native_offset;
      D.30654 = (sizetype) D.30653;
      D.30655 = D.30455 + D.30654;
      ei->handler_start = D.30655;
      tmp = cfg->try_block_holes;
      goto <D.26228>;
      <D.26227>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.30455 = cfg->native_code;
        D.30699 = hole->basic_block;
        D.30700 = D.30699->native_offset;
        D.30699 = hole->basic_block;
        D.30701 = D.30699->native_length;
        D.30702 = D.30700 + D.30701;
        D.30703 = (sizetype) D.30702;
        hole_end = D.30455 + D.30703;
        D.30704 = hole->clause;
        if (D.30704 == ec) goto <D.30705>; else goto <D.30706>;
        <D.30705>:
        D.30707 = ei->try_end;
        if (D.30707 == hole_end) goto <D.30708>; else goto <D.30709>;
        <D.30708>:
        D.30413 = cfg->verbose_level;
        D.30414 = D.30413 > 3;
        D.30415 = (long int) D.30414;
        D.30416 = __builtin_expect (D.30415, 0);
        if (D.30416 != 0) goto <D.30710>; else goto <D.30711>;
        <D.30710>:
        D.30712 = hole->start_offset;
        D.30707 = ei->try_end;
        D.30713 = (long int) D.30707;
        D.30455 = cfg->native_code;
        D.30714 = (long int) D.30455;
        D.30715 = D.30713 - D.30714;
        D.30716 = (int) D.30715;
        printf ("\tShortening try block %d from %x to %x\n", i, D.30716, D.30712);
        <D.30711>:
        D.30455 = cfg->native_code;
        D.30712 = hole->start_offset;
        D.30717 = (sizetype) D.30712;
        D.30718 = D.30455 + D.30717;
        ei->try_end = D.30718;
        goto <D.26226>;
        <D.30709>:
        <D.30706>:
      }
      tmp = tmp->next;
      <D.26228>:
      if (tmp != 0B) goto <D.26227>; else goto <D.26226>;
      <D.26226>:
      D.30633 = ec->flags;
      if (D.30633 == 2) goto <D.30719>; else goto <D.30720>;
      <D.30719>:
      {
        int end_offset;

        D.30634 = ec->handler_offset;
        D.30721 = ec->handler_len;
        D.30722 = D.30634 + D.30721;
        D.30723 = header->code_size;
        if (D.30722 < D.30723) goto <D.30724>; else goto <D.30725>;
        <D.30724>:
        D.30392 = cfg->cil_offset_to_bb;
        D.30634 = ec->handler_offset;
        D.30721 = ec->handler_len;
        D.30722 = D.30634 + D.30721;
        D.30726 = (long unsigned int) D.30722;
        D.30727 = D.30726 * 8;
        D.30728 = D.30392 + D.30727;
        tblock = *D.30728;
        D.30653 = tblock->native_offset;
        if (D.30653 != 0) goto <D.30729>; else goto <D.30730>;
        <D.30729>:
        end_offset = tblock->native_offset;
        goto <D.30731>;
        <D.30730>:
        {
          int j;
          int end;

          D.30634 = ec->handler_offset;
          D.30721 = ec->handler_len;
          D.30722 = D.30634 + D.30721;
          j = (int) D.30722;
          D.30634 = ec->handler_offset;
          end = (int) D.30634;
          goto <D.26235>;
          <D.26234>:
          {
            struct MonoBasicBlock * bb;

            D.30392 = cfg->cil_offset_to_bb;
            D.30732 = (long unsigned int) j;
            D.30733 = D.30732 * 8;
            D.30734 = D.30392 + D.30733;
            bb = *D.30734;
            if (bb != 0B) goto <D.30735>; else goto <D.30736>;
            <D.30735>:
            D.30737 = bb->native_offset;
            if (D.30737 != 0) goto <D.30738>; else goto <D.30739>;
            <D.30738>:
            tblock = bb;
            goto <D.26233>;
            <D.30739>:
            <D.30736>:
          }
          j = j + -1;
          <D.26235>:
          if (j >= end) goto <D.26234>; else goto <D.26233>;
          <D.26233>:
          D.30653 = tblock->native_offset;
          D.30740 = tblock->native_length;
          end_offset = D.30653 + D.30740;
        }
        <D.30731>:
        goto <D.30741>;
        <D.30725>:
        D.30742 = cfg->epilog_begin;
        end_offset = (int) D.30742;
        <D.30741>:
        D.30455 = cfg->native_code;
        D.30743 = (sizetype) end_offset;
        D.30744 = D.30455 + D.30743;
        ei->data.handler_end = D.30744;
      }
      <D.30720>:
    }
    i = i + 1;
    <D.26237>:
    D.30426 = header->num_clauses;
    D.30745 = (int) D.30426;
    if (D.30745 > i) goto <D.26236>; else goto <D.26238>;
    <D.26238>:
  }
  <D.30630>:
  <D.30626>:
  D.30413 = cfg->verbose_level;
  D.30414 = D.30413 > 3;
  D.30415 = (long int) D.30414;
  D.30416 = __builtin_expect (D.30415, 0);
  if (D.30416 != 0) goto <D.30746>; else goto <D.30747>;
  <D.30746>:
  {
    int i;

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

      ei = &jinfo->clauses[i];
      D.30748 = ei->try_start;
      D.30749 = (long int) D.30748;
      D.30455 = cfg->native_code;
      D.30714 = (long int) D.30455;
      D.30750 = D.30749 - D.30714;
      start = (int) D.30750;
      D.30751 = ei->try_end;
      D.30752 = (long int) D.30751;
      D.30455 = cfg->native_code;
      D.30714 = (long int) D.30455;
      D.30753 = D.30752 - D.30714;
      end = (int) D.30753;
      D.30754 = ei->handler_start;
      D.30755 = (long int) D.30754;
      D.30455 = cfg->native_code;
      D.30714 = (long int) D.30455;
      D.30756 = D.30755 - D.30714;
      handler = (int) D.30756;
      D.30757 = ei->data.handler_end;
      D.30758 = (long int) D.30757;
      D.30455 = cfg->native_code;
      D.30714 = (long int) D.30455;
      D.30759 = D.30758 - D.30714;
      handler_end = (int) D.30759;
      D.30760 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.30760, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.26246>:
    D.30761 = jinfo->num_clauses;
    D.30762 = (int) D.30761;
    if (D.30762 > i) goto <D.26245>; else goto <D.26247>;
    <D.26247>:
  }
  <D.30747>:
  D.30763 = cfg->encoded_unwind_ops;
  if (D.30763 != 0B) goto <D.30764>; else goto <D.30765>;
  <D.30764>:
  D.30766 = cfg->encoded_unwind_ops_len;
  D.30763 = cfg->encoded_unwind_ops;
  D.30767 = mono_cache_unwind_info (D.30763, D.30766);
  jinfo->used_regs = D.30767;
  D.30763 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.30763);
  goto <D.30768>;
  <D.30765>:
  D.30769 = cfg->unwind_ops;
  if (D.30769 != 0B) goto <D.30770>; else goto <D.30771>;
  <D.30770>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.30769 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.30769, &info_len);
        info_len.103 = info_len;
        D.30773 = mono_cache_unwind_info (unwind_info, info_len.103);
        jinfo->used_regs = D.30773;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.30771>:
  <D.30768>:
  D.30774 = jinfo;
  return D.30774;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.30776;
  unsigned int D.30779;
  long unsigned int D.30780;
  long unsigned int D.30781;
  long unsigned int D.30782;
  int D.30783;
  void * * D.30784;
  long unsigned int D.30785;
  long unsigned int D.30786;
  void * * D.30787;
  long int D.30788;
  int D.30789;
  long int D.30790;
  int D.30791;
  unsigned char D.30792;
  int D.30793;
  int D.30794;
  int D.30797;
  int D.30798;
  unsigned int i.104;
  long unsigned int D.30800;
  struct GSList * D.30801;
  long int D.30802;
  _Bool D.30803;
  _Bool D.30804;
  _Bool D.30805;
  long int D.30808;
  int D.30813;
  long unsigned int D.30814;
  long unsigned int D.30815;
  struct GSList * * D.30816;
  int D.30817;
  long unsigned int D.30818;
  void * D.30819;
  struct GSList * D.30820;
  struct GSList * D.30821;
  struct MonoInst * D.30823;
  short unsigned int D.30826;
  struct GSList * D.30833;
  long int D.30836;
  _Bool D.30837;
  _Bool D.30838;
  _Bool D.30839;
  int D.30844;
  long unsigned int D.30845;
  long unsigned int D.30846;
  struct GSList * * D.30847;
  int D.30848;
  long unsigned int D.30849;
  void * D.30850;
  struct GSList * D.30851;
  struct GSList * D.30852;
  unsigned int D.30853;
  struct GSList * * D.30856;
  struct GSList * D.30857;
  unsigned int D.30858;
  int D.30859;
  int D.30860;
  long unsigned int D.30861;
  long unsigned int D.30862;
  void * D.30863;
  int D.30868;
  void * D.30869;
  long int D.30870;
  int D.30871;
  int * D.30872;
  int j.105;
  long unsigned int D.30874;
  long unsigned int D.30875;
  int * D.30876;
  unsigned char D.30877;
  unsigned char D.30878;
  union mono_mutex_t * D.30881;
  _Bool D.30884;
  long int D.30885;
  long int D.30886;
  struct MonoMethod * D.30889;
  void * D.30890;
  struct GHashTable * D.30891;
  void * D.30892;
  _Bool D.30897;
  long int D.30898;
  long int D.30899;
  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.30776 = cfg->seq_points;
  if (D.30776 == 0B) goto <D.30777>; else goto <D.30778>;
  <D.30777>:
  return;
  <D.30778>:
  D.30776 = cfg->seq_points;
  D.30779 = D.30776->len;
  D.30780 = (long unsigned int) D.30779;
  D.30781 = D.30780 * 32;
  D.30782 = D.30781 + 8;
  info = monoeg_malloc0 (D.30782);
  D.30776 = cfg->seq_points;
  D.30779 = D.30776->len;
  D.30783 = (int) D.30779;
  info->len = D.30783;
  i = 0;
  goto <D.26095>;
  <D.26094>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.30776 = cfg->seq_points;
    D.30784 = D.30776->pdata;
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30787 = D.30784 + D.30786;
    ins = *D.30787;
    D.30788 = ins->data.op[1].const_val;
    D.30789 = (int) D.30788;
    sp->il_offset = D.30789;
    D.30790 = ins->data.op[0].const_val;
    D.30791 = (int) D.30790;
    sp->native_offset = D.30791;
    D.30792 = ins->flags;
    D.30793 = (int) D.30792;
    D.30794 = D.30793 & 4;
    if (D.30794 != 0) goto <D.30795>; else goto <D.30796>;
    <D.30795>:
    D.30797 = sp->flags;
    D.30798 = D.30797 | 1;
    sp->flags = D.30798;
    <D.30796>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.26095>:
  i.104 = (unsigned int) i;
  D.30776 = cfg->seq_points;
  D.30779 = D.30776->len;
  if (i.104 < D.30779) goto <D.26094>; else goto <D.26096>;
  <D.26096>:
  D.30776 = cfg->seq_points;
  D.30779 = D.30776->len;
  D.30780 = (long unsigned int) D.30779;
  D.30800 = D.30780 * 8;
  next = monoeg_malloc0 (D.30800);
  bb = cfg->bb_entry;
  goto <D.26110>;
  <D.26109>:
  D.30801 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.30801);
  last = 0B;
  l = bb_seq_points;
  goto <D.26100>;
  <D.26099>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.30802 = ins->data.op[1].const_val;
    D.30803 = D.30802 == -1;
    D.30804 = D.30802 == 16777215;
    D.30805 = D.30803 | D.30804;
    if (D.30805 != 0) goto <D.30806>; else goto <D.30807>;
    <D.30806>:
    // predicted unlikely by continue predictor.
    goto <D.26098>;
    <D.30807>:
    D.30808 = ins->data.op[0].const_val;
    if (D.30808 == -1) goto <D.30809>; else goto <D.30810>;
    <D.30809>:
    // predicted unlikely by continue predictor.
    goto <D.26098>;
    <D.30810>:
    if (last != 0B) goto <D.30811>; else goto <D.30812>;
    <D.30811>:
    D.30813 = last->backend.size;
    D.30814 = (long unsigned int) D.30813;
    D.30815 = D.30814 * 8;
    D.30816 = next + D.30815;
    D.30817 = ins->backend.size;
    D.30818 = (long unsigned int) D.30817;
    D.30819 = (void *) D.30818;
    D.30813 = last->backend.size;
    D.30814 = (long unsigned int) D.30813;
    D.30815 = D.30814 * 8;
    D.30816 = next + D.30815;
    D.30820 = *D.30816;
    D.30821 = monoeg_g_slist_append (D.30820, D.30819);
    *D.30816 = D.30821;
    goto <D.30822>;
    <D.30812>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.30822>:
    last = ins;
  }
  <D.26098>:
  l = l->next;
  <D.26100>:
  if (l != 0B) goto <D.26099>; else goto <D.26101>;
  <D.26101>:
  D.30823 = bb->last_ins;
  if (D.30823 != 0B) goto <D.30824>; else goto <D.30825>;
  <D.30824>:
  D.30823 = bb->last_ins;
  D.30826 = D.30823->opcode;
  if (D.30826 == 742) goto <D.30827>; else goto <D.30828>;
  <D.30827>:
  D.30801 = bb->seq_points;
  if (D.30801 != 0B) goto <D.30829>; else goto <D.30830>;
  <D.30829>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.30801 = bb->seq_points;
    l = monoeg_g_slist_last (D.30801);
    if (l != 0B) goto <D.30831>; else goto <D.30832>;
    <D.30831>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.26107>;
    <D.26106>:
    {
      struct GSList * l;

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

        ins = l->data;
        D.30836 = ins->data.op[1].const_val;
        D.30837 = D.30836 != -1;
        D.30838 = D.30836 != 16777215;
        D.30839 = D.30837 & D.30838;
        if (D.30839 != 0) goto <D.30840>; else goto <D.30841>;
        <D.30840>:
        if (ins != endfinally_seq_point) goto <D.30842>; else goto <D.30843>;
        <D.30842>:
        D.30844 = endfinally_seq_point->backend.size;
        D.30845 = (long unsigned int) D.30844;
        D.30846 = D.30845 * 8;
        D.30847 = next + D.30846;
        D.30848 = ins->backend.size;
        D.30849 = (long unsigned int) D.30848;
        D.30850 = (void *) D.30849;
        D.30844 = endfinally_seq_point->backend.size;
        D.30845 = (long unsigned int) D.30844;
        D.30846 = D.30845 * 8;
        D.30847 = next + D.30846;
        D.30851 = *D.30847;
        D.30852 = monoeg_g_slist_append (D.30851, D.30850);
        *D.30847 = D.30852;
        <D.30843>:
        <D.30841>:
      }
      <D.30835>:
    }
    bb2 = bb2->next_bb;
    <D.26107>:
    if (bb2 != 0B) goto <D.26106>; else goto <D.26108>;
    <D.26108>:
    <D.30832>:
  }
  <D.30830>:
  <D.30828>:
  <D.30825>:
  bb = bb->next_bb;
  <D.26110>:
  if (bb != 0B) goto <D.26109>; else goto <D.26111>;
  <D.26111>:
  D.30853 = cfg->verbose_level;
  if (D.30853 > 2) goto <D.30854>; else goto <D.30855>;
  <D.30854>:
  printf ("\nSEQ POINT MAP: \n");
  <D.30855>:
  i = 0;
  goto <D.26123>;
  <D.26122>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30856 = next + D.30786;
    D.30857 = *D.30856;
    D.30858 = monoeg_g_slist_length (D.30857);
    D.30859 = (int) D.30858;
    sp->next_len = D.30859;
    D.30860 = sp->next_len;
    D.30861 = (long unsigned int) D.30860;
    D.30862 = D.30861 * 4;
    D.30863 = monoeg_malloc (D.30862);
    sp->next = D.30863;
    j = 0;
    D.30853 = cfg->verbose_level;
    if (D.30853 > 2) goto <D.30864>; else goto <D.30865>;
    <D.30864>:
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30856 = next + D.30786;
    D.30857 = *D.30856;
    if (D.30857 != 0B) goto <D.30866>; else goto <D.30867>;
    <D.30866>:
    D.30868 = sp->il_offset;
    printf ("\tIL0x%x ->", D.30868);
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30856 = next + D.30786;
    l = *D.30856;
    goto <D.26117>;
    <D.26116>:
    D.30869 = l->data;
    D.30870 = (long int) D.30869;
    next_index = (int) D.30870;
    D.30871 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.30871);
    l = l->next;
    <D.26117>:
    if (l != 0B) goto <D.26116>; else goto <D.26118>;
    <D.26118>:
    printf ("\n");
    <D.30867>:
    <D.30865>:
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30856 = next + D.30786;
    l = *D.30856;
    goto <D.26120>;
    <D.26119>:
    D.30869 = l->data;
    D.30870 = (long int) D.30869;
    next_index = (int) D.30870;
    D.30872 = sp->next;
    j.105 = j;
    j = j.105 + 1;
    D.30874 = (long unsigned int) j.105;
    D.30875 = D.30874 * 4;
    D.30876 = D.30872 + D.30875;
    *D.30876 = next_index;
    l = l->next;
    <D.26120>:
    if (l != 0B) goto <D.26119>; else goto <D.26121>;
    <D.26121>:
    D.30785 = (long unsigned int) i;
    D.30786 = D.30785 * 8;
    D.30856 = next + D.30786;
    D.30857 = *D.30856;
    monoeg_g_slist_free (D.30857);
  }
  i = i + 1;
  <D.26123>:
  i.104 = (unsigned int) i;
  D.30776 = cfg->seq_points;
  D.30779 = D.30776->len;
  if (i.104 < D.30779) goto <D.26122>; else goto <D.26124>;
  <D.26124>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.30877 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.30878 = D.30877 & 64;
  if (D.30878 == 0) goto <D.30879>; else goto <D.30880>;
  <D.30879>:
  {
    int ret;

    D.30881 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30881);
    if (ret != 0) goto <D.30882>; else goto <D.30883>;
    <D.30882>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30883>:
    D.30884 = ret != 0;
    D.30885 = (long int) D.30884;
    D.30886 = __builtin_expect (D.30885, 0);
    if (D.30886 != 0) goto <D.30887>; else goto <D.30888>;
    <D.30887>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.30888>:
  }
  D.30889 = cfg->method_to_register;
  D.30890 = domain->runtime_info;
  D.30891 = MEM[(struct MonoJitDomainInfo *)D.30890].seq_points;
  D.30892 = monoeg_g_hash_table_lookup (D.30891, D.30889);
  if (D.30892 == 0B) goto <D.30893>; else goto <D.30894>;
  <D.30893>:
  D.30889 = cfg->method_to_register;
  D.30890 = domain->runtime_info;
  D.30891 = MEM[(struct MonoJitDomainInfo *)D.30890].seq_points;
  monoeg_g_hash_table_insert_replace (D.30891, D.30889, info, 0);
  <D.30894>:
  {
    int ret;

    D.30881 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30881);
    if (ret != 0) goto <D.30895>; else goto <D.30896>;
    <D.30895>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30896>:
    D.30897 = ret != 0;
    D.30898 = (long int) D.30897;
    D.30899 = __builtin_expect (D.30898, 0);
    if (D.30899 != 0) goto <D.30900>; else goto <D.30901>;
    <D.30900>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.30901>:
  }
  <D.30880>:
  D.30776 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.30776, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.30903;
  long unsigned int D.30904;
  long unsigned int D.30905;
  struct MonoBasicBlock * * D.30906;
  struct MonoInst * D.30907;
  long unsigned int D.30910;
  long unsigned int D.30911;
  struct GSList * * D.30912;
  void * D.30913;
  long int D.30914;
  unsigned int D.30915;
  unsigned int dst_index.106;
  long unsigned int D.30920;
  void * D.30921;
  struct GSList * D.30922;
  struct GSList * D.30923;
  int D.30927;
  short int D.30928;
  int D.30929;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.26079>;
  <D.26078>:
  D.30903 = bb->in_bb;
  D.30904 = (long unsigned int) i;
  D.30905 = D.30904 * 8;
  D.30906 = D.30903 + D.30905;
  in_bb = *D.30906;
  D.30907 = in_bb->last_seq_point;
  if (D.30907 != 0B) goto <D.30908>; else goto <D.30909>;
  <D.30908>:
  {
    int src_index;
    int dst_index;

    D.30907 = in_bb->last_seq_point;
    src_index = D.30907->backend.size;
    dst_index = ins->backend.size;
    D.30910 = (long unsigned int) src_index;
    D.30911 = D.30910 * 8;
    D.30912 = next + D.30911;
    l = *D.30912;
    goto <D.26077>;
    <D.26076>:
    D.30913 = l->data;
    D.30914 = (long int) D.30913;
    D.30915 = (unsigned int) D.30914;
    dst_index.106 = (unsigned int) dst_index;
    if (D.30915 == dst_index.106) goto <D.26075>; else goto <D.30917>;
    <D.30917>:
    l = l->next;
    <D.26077>:
    if (l != 0B) goto <D.26076>; else goto <D.26075>;
    <D.26075>:
    if (l == 0B) goto <D.30918>; else goto <D.30919>;
    <D.30918>:
    D.30910 = (long unsigned int) src_index;
    D.30911 = D.30910 * 8;
    D.30912 = next + D.30911;
    D.30920 = (long unsigned int) dst_index;
    D.30921 = (void *) D.30920;
    D.30910 = (long unsigned int) src_index;
    D.30911 = D.30910 * 8;
    D.30912 = next + D.30911;
    D.30922 = *D.30912;
    D.30923 = monoeg_g_slist_append (D.30922, D.30921);
    *D.30912 = D.30923;
    <D.30919>:
  }
  goto <D.30924>;
  <D.30909>:
  if (depth <= 4) goto <D.30925>; else goto <D.30926>;
  <D.30925>:
  D.30927 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.30927);
  <D.30926>:
  <D.30924>:
  i = i + 1;
  <D.26079>:
  D.30928 = bb->in_count;
  D.30929 = (int) D.30928;
  if (D.30929 > i) goto <D.26078>; else goto <D.26080>;
  <D.26080>:
}


mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoMethod * D.30930;
  struct MonoInternalHashTable * D.30931;
  unsigned char D.30934;
  unsigned char D.30935;
  int inited.107;
  int lookups.108;
  int lookups.109;
  int failed_lookups.110;
  int failed_lookups.111;
  struct MonoJitInfo * D.30947;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.30930 = mini_get_shared_method (method);
  D.30931 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.30931, D.30930);
  if (ji != 0B) goto <D.30932>; else goto <D.30933>;
  <D.30932>:
  D.30934 = BIT_FIELD_REF <*ji, 8, 272>;
  D.30935 = D.30934 & 2;
  if (D.30935 == 0) goto <D.30936>; else goto <D.30937>;
  <D.30936>:
  ji = 0B;
  <D.30937>:
  <D.30933>:
  inited.107 = inited;
  if (inited.107 == 0) goto <D.30939>; else goto <D.30940>;
  <D.30939>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.30940>:
  lookups.108 = lookups;
  lookups.109 = lookups.108 + 1;
  lookups = lookups.109;
  if (ji == 0B) goto <D.30943>; else goto <D.30944>;
  <D.30943>:
  failed_lookups.110 = failed_lookups;
  failed_lookups.111 = failed_lookups.110 + 1;
  failed_lookups = failed_lookups.111;
  <D.30944>:
  D.30947 = ji;
  return D.30947;
}


mono_enable_jit_map ()
{
  struct FILE * perf_map_file.112;
  int D.30952;
  struct FILE * perf_map_file.113;

  perf_map_file.112 = perf_map_file;
  if (perf_map_file.112 == 0B) goto <D.30950>; else goto <D.30951>;
  <D.30950>:
  {
    char name[64];

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


mono_emit_jit_tramp (void * start, int size, const char * desc)
{
  struct FILE * perf_map_file.114;
  long long unsigned int start.115;

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


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.30958;

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


mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.116;
  struct MonoMethod * D.30963;
  int D.30964;
  void * D.30965;

  perf_map_file.116 = perf_map_file;
  if (perf_map_file.116 != 0B) goto <D.30961>; else goto <D.30962>;
  <D.30961>:
  {
    char * name;

    D.30963 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.30963, 1);
    D.30964 = jinfo->code_size;
    D.30965 = jinfo->code_start;
    mono_emit_jit_tramp (D.30965, D.30964, name);
    monoeg_g_free (name);
  }
  <D.30962>:
}


mono_jit_map_is_enabled ()
{
  gboolean D.30966;
  struct FILE * perf_map_file.117;
  _Bool D.30968;

  perf_map_file.117 = perf_map_file;
  D.30968 = perf_map_file.117 != 0B;
  D.30966 = (gboolean) D.30968;
  return D.30966;
}


mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.118;
  unsigned int D.30971;
  struct MonoException * ex.119;
  _Bool D.30975;
  long int D.30976;
  long int D.30977;
  void * D.30980;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.118 = default_opt;
      D.30971 = mono_get_optimizations_for_method (method, default_opt.118);
      code = mono_jit_compile_method_with_opt (method, D.30971, &ex);
      if (code == 0B) goto <D.30972>; else goto <D.30973>;
      <D.30972>:
      ex.119 = ex;
      D.30975 = ex.119 == 0B;
      D.30976 = (long int) D.30975;
      D.30977 = __builtin_expect (D.30976, 0);
      if (D.30977 != 0) goto <D.30978>; else goto <D.30979>;
      <D.30978>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.30979>:
      ex.119 = ex;
      mono_raise_exception (ex.119);
      <D.30973>:
      D.30980 = code;
      return D.30980;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  unsigned char D.30983;
  unsigned char D.30984;
  <unnamed type> D.30989;
  void * D.30992;
  _Bool D.30993;
  long int D.30994;
  long int D.30995;
  unsigned char D.30998;
  unsigned char D.30999;
  struct MonoClass * D.31004;
  struct MonoImage * D.31005;
  struct MonoImage * D.31006;
  unsigned char D.31008;
  unsigned int D.31009;
  _Bool D.31015;
  long int D.31016;
  long int D.31017;
  <unnamed type> D.31020;
  unsigned char D.31032;
  unsigned char D.31033;
  int D.31034;
  int D.31035;
  _Bool D.31036;
  long int D.31037;
  long int D.31038;
  _Bool D.31041;
  int D.31042;
  void * D.31045;
  void * D.31046;
  int opt.120;
  unsigned char D.31050;
  _Bool D.31051;
  _Bool D.31052;
  _Bool D.31053;
  struct MonoDomain * D.31056;
  _Bool D.31057;
  long int D.31058;
  long int D.31059;
  _Bool D.31066;
  long int D.31067;
  long int D.31068;
  const void * D.31071;
  _Bool D.31076;
  long int D.31077;
  long int D.31078;
  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.30983 = BIT_FIELD_REF <*method, 8, 256>;
  D.30984 = D.30983 & 124;
  if (D.30984 == 24) goto <D.30985>; else goto <D.30986>;
  <D.30985>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.30986>:
  if (winfo != 0B) goto <D.30987>; else goto <D.30988>;
  <D.30987>:
  D.30989 = winfo->subtype;
  if (D.30989 == 15) goto <D.30990>; else goto <D.30991>;
  <D.30990>:
  D.30992 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.30992);
  D.30993 = callinfo == 0B;
  D.30994 = (long int) D.30993;
  D.30995 = __builtin_expect (D.30994, 0);
  if (D.30995 != 0) goto <D.30996>; else goto <D.30997>;
  <D.30996>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.30997>:
  opt = opt | 512;
  <D.30991>:
  <D.30988>:
  D.30998 = BIT_FIELD_REF <*method, 8, 264>;
  D.30999 = D.30998 & 2;
  if (D.30999 != 0) goto <D.31000>; else goto <D.31001>;
  <D.31000>:
  opt = opt & 4294966783;
  <D.31001>:
  D.31004 = method->klass;
  D.31005 = D.31004->image;
  D.31006 = mono_get_corlib ();
  if (D.31005 != D.31006) goto <D.31002>; else goto <D.31007>;
  <D.31007>:
  D.30998 = BIT_FIELD_REF <*method, 8, 264>;
  D.31008 = D.30998 & 16;
  if (D.31008 != 0) goto <D.31002>; else goto <D.31003>;
  <D.31002>:
  opt = opt & 4294966783;
  <D.31003>:
  D.31009 = opt & 512;
  if (D.31009 != 0) goto <D.31010>; else goto <D.31011>;
  <D.31010>:
  target_domain = mono_get_root_domain ();
  goto <D.31012>;
  <D.31011>:
  target_domain = domain;
  <D.31012>:
  D.30983 = BIT_FIELD_REF <*method, 8, 256>;
  D.30984 = D.30983 & 124;
  if (D.30984 == 100) goto <D.31013>; else goto <D.31014>;
  <D.31013>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.31015 = info == 0B;
    D.31016 = (long int) D.31015;
    D.31017 = __builtin_expect (D.31016, 0);
    if (D.31017 != 0) goto <D.31018>; else goto <D.31019>;
    <D.31018>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.31019>:
    D.31020 = info->subtype;
    if (D.31020 == 17) goto <D.31021>; else goto <D.31022>;
    <D.31021>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.30998 = BIT_FIELD_REF <*method, 8, 264>;
      D.31008 = D.30998 & 16;
      if (D.31008 != 0) goto <D.31023>; else goto <D.31024>;
      <D.31023>:
      ctx = mono_method_get_context (method);
      <D.31024>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.31025>; else goto <D.31026>;
      <D.31025>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.31026>:
    }
    <D.31022>:
  }
  <D.31014>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.31027>; else goto <D.31028>;
  <D.31027>:
  if (domain == target_domain) goto <D.31029>; else goto <D.31031>;
  <D.31031>:
  D.31032 = BIT_FIELD_REF <*info, 8, 264>;
  D.31033 = D.31032 & 128;
  if (D.31033 != 0) goto <D.31029>; else goto <D.31030>;
  <D.31029>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.31034 = mono_jit_stats.methods_lookups;
    D.31035 = D.31034 + 1;
    mono_jit_stats.methods_lookups = D.31035;
    D.31004 = method->klass;
    vtable = mono_class_vtable (domain, D.31004);
    D.31036 = vtable == 0B;
    D.31037 = (long int) D.31036;
    D.31038 = __builtin_expect (D.31037, 0);
    if (D.31038 != 0) goto <D.31039>; else goto <D.31040>;
    <D.31039>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.31040>:
    D.31041 = ex == 0B;
    D.31042 = (int) D.31041;
    tmpEx = mono_runtime_class_init_full (vtable, D.31042);
    if (tmpEx != 0B) goto <D.31043>; else goto <D.31044>;
    <D.31043>:
    *ex = tmpEx;
    D.31045 = 0B;
    return D.31045;
    <D.31044>:
    D.31046 = info->code_start;
    D.31045 = mono_create_ftnptr (target_domain, D.31046);
    return D.31045;
  }
  <D.31030>:
  <D.31028>:
  opt.120 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.120, ex);
  if (code == 0B) goto <D.31048>; else goto <D.31049>;
  <D.31048>:
  D.31045 = 0B;
  return D.31045;
  <D.31049>:
  D.30983 = BIT_FIELD_REF <*method, 8, 256>;
  D.31050 = D.30983 & 124;
  D.31051 = D.31050 == 96;
  D.31052 = D.31050 == 112;
  D.31053 = D.31051 | D.31052;
  if (D.31053 != 0) goto <D.31054>; else goto <D.31055>;
  <D.31054>:
  {
    struct MonoDomain * d;

    try
      {
        D.31056 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.31056, code, &d);
        D.31057 = ji == 0B;
        D.31058 = (long int) D.31057;
        D.31059 = __builtin_expect (D.31058, 0);
        if (D.31059 != 0) goto <D.31060>; else goto <D.31061>;
        <D.31060>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.31061>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.31055>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.31062>; else goto <D.31063>;
  <D.31062>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    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", 6230, "ret == 0");
    <D.31070>:
  }
  D.31071 = callinfo->wrapper;
  if (D.31071 == 0B) goto <D.31072>; else goto <D.31073>;
  <D.31072>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.31073>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31074>; else goto <D.31075>;
    <D.31074>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31075>:
    D.31076 = ret != 0;
    D.31077 = (long int) D.31076;
    D.31078 = __builtin_expect (D.31077, 0);
    if (D.31078 != 0) goto <D.31079>; else goto <D.31080>;
    <D.31079>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.31080>:
  }
  mono_loader_unlock ();
  <D.31063>:
  D.31045 = p;
  return D.31045;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.31082;
  _Bool D.31085;
  long int D.31086;
  long int D.31087;
  _Bool D.31092;
  long int D.31093;
  long int D.31094;
  struct MonoJitInfo * D.31097;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.31082 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.31082);
    if (ret != 0) goto <D.31083>; else goto <D.31084>;
    <D.31083>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31084>:
    D.31085 = ret != 0;
    D.31086 = (long int) D.31085;
    D.31087 = __builtin_expect (D.31086, 0);
    if (D.31087 != 0) goto <D.31088>; else goto <D.31089>;
    <D.31088>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.31089>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.31082 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31082);
    if (ret != 0) goto <D.31090>; else goto <D.31091>;
    <D.31090>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31091>:
    D.31092 = ret != 0;
    D.31093 = (long int) D.31092;
    D.31094 = __builtin_expect (D.31093, 0);
    if (D.31094 != 0) goto <D.31095>; else goto <D.31096>;
    <D.31095>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.31096>:
  }
  mono_loader_unlock ();
  D.31097 = info;
  return D.31097;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.31099;
  struct MonoJitInfo * D.31102;
  int D.31103;
  struct MonoJitInfo * ji;

  D.31099 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.31099, method);
  if (ji != 0B) goto <D.31100>; else goto <D.31101>;
  <D.31100>:
  D.31102 = ji;
  return D.31102;
  <D.31101>:
  D.31103 = mono_method_is_generic_sharable (method, 0);
  if (D.31103 == 0) goto <D.31104>; else goto <D.31105>;
  <D.31104>:
  D.31102 = 0B;
  return D.31102;
  <D.31105>:
  D.31102 = mono_domain_lookup_shared_generic (domain, method);
  return D.31102;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.31107;
  struct MonoMethod * method.121;
  struct MonoClass * D.31111;
  _Bool D.31114;
  long int D.31115;
  long int D.31116;
  void * D.31119;
  short unsigned int D.31122;
  int D.31123;
  int D.31124;
  short unsigned int D.31126;
  int D.31127;
  int D.31128;
  void * D.31129;
  void * D.31134;
  int D.31136;
  struct MonoImage * D.31139;
  char * D.31140;
  char * D.31141;
  int check_for_pending_exc.122;
  void * D.31144;
  struct MonoDomain * D.31147;
  int D.31150;
  struct MonoClass * D.31153;
  struct MonoClass * D.31154;
  char D.31158;
  int D.26485;
  int iftmp.123;
  int D.26484;
  const char[6] * D.31163;
  unsigned char D.31164;
  int D.31165;
  unsigned char D.31166;
  int D.31167;
  _Bool D.31168;
  _Bool D.31169;
  _Bool D.31170;
  const unsigned char * D.31173;
  unsigned char D.31174;
  int D.31175;
  const unsigned char * D.31176;
  unsigned char D.31177;
  int D.31178;
  _Bool D.31179;
  _Bool D.31180;
  const unsigned char * D.31183;
  unsigned char D.31184;
  int D.31185;
  const unsigned char * D.31186;
  unsigned char D.31187;
  int D.31188;
  _Bool D.31189;
  _Bool D.31190;
  const unsigned char * D.31193;
  unsigned char D.31194;
  int D.31195;
  const unsigned char * D.31196;
  unsigned char D.31197;
  int D.31198;
  _Bool D.31201;
  long int D.31202;
  long int D.31203;
  const void * D.31206;
  int D.26495;
  int iftmp.124;
  int D.26494;
  const char[7] * D.31212;
  unsigned char D.31213;
  int D.31214;
  unsigned char D.31215;
  int D.31216;
  _Bool D.31217;
  _Bool D.31218;
  _Bool D.31219;
  const unsigned char * D.31222;
  unsigned char D.31223;
  int D.31224;
  const unsigned char * D.31225;
  unsigned char D.31226;
  int D.31227;
  _Bool D.31228;
  _Bool D.31229;
  const unsigned char * D.31232;
  unsigned char D.31233;
  int D.31234;
  const unsigned char * D.31235;
  unsigned char D.31236;
  int D.31237;
  _Bool D.31238;
  _Bool D.31239;
  const unsigned char * D.31242;
  unsigned char D.31243;
  int D.31244;
  const unsigned char * D.31245;
  unsigned char D.31246;
  int D.31247;
  int D.26504;
  int iftmp.125;
  int D.26503;
  const char[12] * D.31255;
  unsigned char D.31256;
  int D.31257;
  unsigned char D.31258;
  int D.31259;
  _Bool D.31260;
  _Bool D.31261;
  _Bool D.31262;
  const unsigned char * D.31265;
  unsigned char D.31266;
  int D.31267;
  const unsigned char * D.31268;
  unsigned char D.31269;
  int D.31270;
  _Bool D.31271;
  _Bool D.31272;
  const unsigned char * D.31275;
  unsigned char D.31276;
  int D.31277;
  const unsigned char * D.31278;
  unsigned char D.31279;
  int D.31280;
  _Bool D.31281;
  _Bool D.31282;
  const unsigned char * D.31285;
  unsigned char D.31286;
  int D.31287;
  const unsigned char * D.31288;
  unsigned char D.31289;
  int D.31290;
  void * D.31293;
  int D.26513;
  int iftmp.126;
  int D.26512;
  const char[10] * D.31299;
  unsigned char D.31300;
  int D.31301;
  unsigned char D.31302;
  int D.31303;
  _Bool D.31304;
  _Bool D.31305;
  _Bool D.31306;
  const unsigned char * D.31309;
  unsigned char D.31310;
  int D.31311;
  const unsigned char * D.31312;
  unsigned char D.31313;
  int D.31314;
  _Bool D.31315;
  _Bool D.31316;
  const unsigned char * D.31319;
  unsigned char D.31320;
  int D.31321;
  const unsigned char * D.31322;
  unsigned char D.31323;
  int D.31324;
  _Bool D.31325;
  _Bool D.31326;
  const unsigned char * D.31329;
  unsigned char D.31330;
  int D.31331;
  const unsigned char * D.31332;
  unsigned char D.31333;
  int D.31334;
  void * D.31338;
  struct MonoImage * D.31339;
  struct MonoException * D.31340;
  unsigned char D.31341;
  unsigned char D.31342;
  <unnamed type> D.31345;
  unsigned int D.31346;
  _Bool D.31349;
  struct MonoTrampInfo * in_tinfo.127;
  struct MonoTrampInfo * out_tinfo.128;
  int mono_aot_only.129;
  const char * iftmp.130;
  struct MonoTrampInfo * tinfo.131;
  struct MonoDomain * D.31368;
  struct MonoException * D.31374;
  unsigned int opt.132;
  double D.31376;
  double D.31377;
  double D.31378;
  unsigned int D.31379;
  void * D.31383;
  char * D.31389;
  guint32 * D.31403;
  struct MonoMethod * D.31404;
  void * * D.31405;
  struct MonoDomain * D.31406;
  unsigned int D.31409;
  unsigned int D.31410;
  union mono_mutex_t * D.31413;
  _Bool D.31416;
  long int D.31417;
  long int D.31418;
  union mono_mutex_t * D.31421;
  _Bool D.31424;
  long int D.31425;
  long int D.31426;
  struct MonoDomain * D.31433;
  unsigned char D.31435;
  unsigned char D.31436;
  struct MonoJitInfo * D.31439;
  struct MonoMethod * D.31440;
  struct MonoInternalHashTable * D.31441;
  _Bool D.31444;
  long int D.31445;
  long int D.31446;
  struct MonoGenericSharingContext * D.31449;
  int D.31452;
  long unsigned int D.31455;
  long unsigned int D.31456;
  int D.31457;
  long unsigned int D.31460;
  long unsigned int D.31461;
  _Bool D.31465;
  long int D.31466;
  long int D.31467;
  int D.31470;
  int D.31471;
  int D.31472;
  int D.31473;
  int D.31474;
  int D.31475;
  int D.31476;
  int D.31477;
  int D.31478;
  int D.31479;
  int D.31480;
  int D.31481;
  int D.31482;
  int D.31483;
  int D.31484;
  int D.31485;
  int D.31486;
  int D.31487;
  int D.31488;
  int D.31489;
  int D.31490;
  int D.31491;
  int D.31492;
  int D.31493;
  int D.31494;
  int D.31495;
  int D.31496;
  int D.31497;
  int D.31498;
  void * D.31499;
  struct GHashTable * D.31500;
  void * D.31505;
  _Bool D.31508;
  long int D.31509;
  long int D.31510;
  _Bool D.31515;
  long int D.31516;
  long int D.31517;
  unsigned int D.31520;
  struct MonoMethod * D.31525;
  struct MonoMethod * D.31528;
  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.31107 = opt & 65536;
  if (D.31107 != 0) goto <D.31108>; else goto <D.31109>;
  <D.31108>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.121 = method;
    D.31111 = method.121->klass;
    mono_class_init (D.31111);
    method.121 = method;
    code = mono_aot_get_method (domain, method.121);
    if (code != 0B) goto <D.31112>; else goto <D.31113>;
    <D.31112>:
    method.121 = method;
    D.31111 = method.121->klass;
    vtable = mono_class_vtable (domain, D.31111);
    D.31114 = vtable == 0B;
    D.31115 = (long int) D.31114;
    D.31116 = __builtin_expect (D.31115, 0);
    if (D.31116 != 0) goto <D.31117>; else goto <D.31118>;
    <D.31117>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.31118>:
    mono_runtime_class_init (vtable);
    D.31119 = code;
    return D.31119;
    <D.31113>:
  }
  <D.31109>:
  method.121 = method;
  D.31122 = method.121->iflags;
  D.31123 = (int) D.31122;
  D.31124 = D.31123 & 4096;
  if (D.31124 != 0) goto <D.31120>; else goto <D.31125>;
  <D.31125>:
  method.121 = method;
  D.31126 = method.121->flags;
  D.31127 = (int) D.31126;
  D.31128 = D.31127 & 8192;
  if (D.31128 != 0) goto <D.31120>; else goto <D.31121>;
  <D.31120>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.31129 = piinfo->addr;
    if (D.31129 == 0B) goto <D.31130>; else goto <D.31131>;
    <D.31130>:
    method.121 = method;
    D.31122 = method.121->iflags;
    D.31123 = (int) D.31122;
    D.31124 = D.31123 & 4096;
    if (D.31124 != 0) goto <D.31132>; else goto <D.31133>;
    <D.31132>:
    method.121 = method;
    D.31134 = mono_lookup_internal_call (method.121);
    piinfo->addr = D.31134;
    goto <D.31135>;
    <D.31133>:
    method.121 = method;
    D.31122 = method.121->iflags;
    D.31123 = (int) D.31122;
    D.31136 = D.31123 & 1;
    if (D.31136 != 0) goto <D.31137>; else goto <D.31138>;
    <D.31137>:
    method.121 = method;
    D.31111 = method.121->klass;
    D.31139 = D.31111->image;
    D.31140 = D.31139->name;
    method.121 = method;
    D.31141 = mono_method_full_name (method.121, 1);
    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.31141, D.31140);
    goto <D.31142>;
    <D.31138>:
    method.121 = method;
    mono_lookup_pinvoke_call (method.121, 0B, 0B);
    <D.31142>:
    <D.31135>:
    <D.31131>:
    check_for_pending_exc.122 = check_for_pending_exc;
    method.121 = method;
    nm = mono_marshal_get_native_wrapper (method.121, check_for_pending_exc.122, 0);
    D.31144 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.31144);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.31145>; else goto <D.31146>;
    <D.31145>:
    D.31147 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.31147, code);
    <D.31146>:
    if (jinfo != 0B) goto <D.31148>; else goto <D.31149>;
    <D.31148>:
    method.121 = method;
    mono_profiler_method_end_jit (method.121, jinfo, 0);
    <D.31149>:
    D.31119 = code;
    return D.31119;
  }
  <D.31121>:
  method.121 = method;
  D.31122 = method.121->iflags;
  D.31123 = (int) D.31122;
  D.31150 = D.31123 & 3;
  if (D.31150 != 0) goto <D.31151>; else goto <D.31152>;
  <D.31151>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.121 = method;
    name = method.121->name;
    method.121 = method;
    D.31111 = method.121->klass;
    D.31153 = D.31111->parent;
    D.31154 = mono_defaults.multicastdelegate_class;
    if (D.31153 == D.31154) goto <D.31155>; else goto <D.31156>;
    <D.31155>:
    D.31158 = *name;
    if (D.31158 == 46) goto <D.31159>; else goto <D.31157>;
    <D.31159>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.31161>; else goto <D.31162>;
      <D.31161>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = name;
        D.31163 = ".ctor";
        D.31164 = MEM[(const unsigned char *)D.31163];
        D.31165 = (int) D.31164;
        D.31166 = *__s2;
        D.31167 = (int) D.31166;
        __result = D.31165 - D.31167;
        {
          D.31168 = __s2_len != 0;
          D.31169 = __result == 0;
          D.31170 = D.31168 & D.31169;
          if (D.31170 != 0) goto <D.31171>; else goto <D.31172>;
          <D.31171>:
          D.31173 = &MEM[(void *)".ctor" + 1B];
          D.31174 = *D.31173;
          D.31175 = (int) D.31174;
          D.31176 = __s2 + 1;
          D.31177 = *D.31176;
          D.31178 = (int) D.31177;
          __result = D.31175 - D.31178;
          D.31179 = __s2_len > 1;
          D.31169 = __result == 0;
          D.31180 = D.31179 & D.31169;
          if (D.31180 != 0) goto <D.31181>; else goto <D.31182>;
          <D.31181>:
          D.31183 = &MEM[(void *)".ctor" + 2B];
          D.31184 = *D.31183;
          D.31185 = (int) D.31184;
          D.31186 = __s2 + 2;
          D.31187 = *D.31186;
          D.31188 = (int) D.31187;
          __result = D.31185 - D.31188;
          D.31189 = __s2_len > 2;
          D.31169 = __result == 0;
          D.31190 = D.31189 & D.31169;
          if (D.31190 != 0) goto <D.31191>; else goto <D.31192>;
          <D.31191>:
          D.31193 = &MEM[(void *)".ctor" + 3B];
          D.31194 = *D.31193;
          D.31195 = (int) D.31194;
          D.31196 = __s2 + 3;
          D.31197 = *D.31196;
          D.31198 = (int) D.31197;
          __result = D.31195 - D.31198;
          <D.31192>:
          <D.31182>:
          <D.31172>:
        }
        D.26484 = __result;
      }
      iftmp.123 = -D.26484;
      goto <D.31199>;
      <D.31162>:
      iftmp.123 = __builtin_strcmp (name, ".ctor");
      <D.31199>:
      D.26485 = iftmp.123;
    }
    if (D.26485 == 0) goto <D.31200>; else goto <D.31157>;
    <D.31200>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.31201 = mi == 0B;
      D.31202 = (long int) D.31201;
      D.31203 = __builtin_expect (D.31202, 0);
      if (D.31203 != 0) goto <D.31204>; else goto <D.31205>;
      <D.31204>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.31205>:
      D.31206 = mono_icall_get_wrapper_full (mi, 1);
      D.31119 = mono_get_addr_from_ftnptr (D.31206);
      return D.31119;
    }
    <D.31157>:
    D.31158 = *name;
    if (D.31158 == 73) goto <D.31208>; else goto <D.31207>;
    <D.31208>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.31210>; else goto <D.31211>;
      <D.31210>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = name;
        D.31212 = "Invoke";
        D.31213 = MEM[(const unsigned char *)D.31212];
        D.31214 = (int) D.31213;
        D.31215 = *__s2;
        D.31216 = (int) D.31215;
        __result = D.31214 - D.31216;
        {
          D.31217 = __s2_len != 0;
          D.31218 = __result == 0;
          D.31219 = D.31217 & D.31218;
          if (D.31219 != 0) goto <D.31220>; else goto <D.31221>;
          <D.31220>:
          D.31222 = &MEM[(void *)"Invoke" + 1B];
          D.31223 = *D.31222;
          D.31224 = (int) D.31223;
          D.31225 = __s2 + 1;
          D.31226 = *D.31225;
          D.31227 = (int) D.31226;
          __result = D.31224 - D.31227;
          D.31228 = __s2_len > 1;
          D.31218 = __result == 0;
          D.31229 = D.31228 & D.31218;
          if (D.31229 != 0) goto <D.31230>; else goto <D.31231>;
          <D.31230>:
          D.31232 = &MEM[(void *)"Invoke" + 2B];
          D.31233 = *D.31232;
          D.31234 = (int) D.31233;
          D.31235 = __s2 + 2;
          D.31236 = *D.31235;
          D.31237 = (int) D.31236;
          __result = D.31234 - D.31237;
          D.31238 = __s2_len > 2;
          D.31218 = __result == 0;
          D.31239 = D.31238 & D.31218;
          if (D.31239 != 0) goto <D.31240>; else goto <D.31241>;
          <D.31240>:
          D.31242 = &MEM[(void *)"Invoke" + 3B];
          D.31243 = *D.31242;
          D.31244 = (int) D.31243;
          D.31245 = __s2 + 3;
          D.31246 = *D.31245;
          D.31247 = (int) D.31246;
          __result = D.31244 - D.31247;
          <D.31241>:
          <D.31231>:
          <D.31221>:
        }
        D.26494 = __result;
      }
      iftmp.124 = -D.26494;
      goto <D.31248>;
      <D.31211>:
      iftmp.124 = __builtin_strcmp (name, "Invoke");
      <D.31248>:
      D.26495 = iftmp.124;
    }
    if (D.26495 == 0) goto <D.31249>; else goto <D.31207>;
    <D.31249>:
    method.121 = method;
    D.31111 = method.121->klass;
    D.31119 = mono_create_delegate_trampoline (target_domain, D.31111);
    return D.31119;
    <D.31207>:
    D.31158 = *name;
    if (D.31158 == 66) goto <D.31251>; else goto <D.31250>;
    <D.31251>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 11;
      if (__s2_len <= 3) goto <D.31253>; else goto <D.31254>;
      <D.31253>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = name;
        D.31255 = "BeginInvoke";
        D.31256 = MEM[(const unsigned char *)D.31255];
        D.31257 = (int) D.31256;
        D.31258 = *__s2;
        D.31259 = (int) D.31258;
        __result = D.31257 - D.31259;
        {
          D.31260 = __s2_len != 0;
          D.31261 = __result == 0;
          D.31262 = D.31260 & D.31261;
          if (D.31262 != 0) goto <D.31263>; else goto <D.31264>;
          <D.31263>:
          D.31265 = &MEM[(void *)"BeginInvoke" + 1B];
          D.31266 = *D.31265;
          D.31267 = (int) D.31266;
          D.31268 = __s2 + 1;
          D.31269 = *D.31268;
          D.31270 = (int) D.31269;
          __result = D.31267 - D.31270;
          D.31271 = __s2_len > 1;
          D.31261 = __result == 0;
          D.31272 = D.31271 & D.31261;
          if (D.31272 != 0) goto <D.31273>; else goto <D.31274>;
          <D.31273>:
          D.31275 = &MEM[(void *)"BeginInvoke" + 2B];
          D.31276 = *D.31275;
          D.31277 = (int) D.31276;
          D.31278 = __s2 + 2;
          D.31279 = *D.31278;
          D.31280 = (int) D.31279;
          __result = D.31277 - D.31280;
          D.31281 = __s2_len > 2;
          D.31261 = __result == 0;
          D.31282 = D.31281 & D.31261;
          if (D.31282 != 0) goto <D.31283>; else goto <D.31284>;
          <D.31283>:
          D.31285 = &MEM[(void *)"BeginInvoke" + 3B];
          D.31286 = *D.31285;
          D.31287 = (int) D.31286;
          D.31288 = __s2 + 3;
          D.31289 = *D.31288;
          D.31290 = (int) D.31289;
          __result = D.31287 - D.31290;
          <D.31284>:
          <D.31274>:
          <D.31264>:
        }
        D.26503 = __result;
      }
      iftmp.125 = -D.26503;
      goto <D.31291>;
      <D.31254>:
      iftmp.125 = __builtin_strcmp (name, "BeginInvoke");
      <D.31291>:
      D.26504 = iftmp.125;
    }
    if (D.26504 == 0) goto <D.31292>; else goto <D.31250>;
    <D.31292>:
    method.121 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.121);
    D.31293 = mono_compile_method (nm);
    D.31119 = mono_get_addr_from_ftnptr (D.31293);
    return D.31119;
    <D.31250>:
    D.31158 = *name;
    if (D.31158 == 69) goto <D.31294>; else goto <D.31295>;
    <D.31294>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 9;
      if (__s2_len <= 3) goto <D.31297>; else goto <D.31298>;
      <D.31297>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = name;
        D.31299 = "EndInvoke";
        D.31300 = MEM[(const unsigned char *)D.31299];
        D.31301 = (int) D.31300;
        D.31302 = *__s2;
        D.31303 = (int) D.31302;
        __result = D.31301 - D.31303;
        {
          D.31304 = __s2_len != 0;
          D.31305 = __result == 0;
          D.31306 = D.31304 & D.31305;
          if (D.31306 != 0) goto <D.31307>; else goto <D.31308>;
          <D.31307>:
          D.31309 = &MEM[(void *)"EndInvoke" + 1B];
          D.31310 = *D.31309;
          D.31311 = (int) D.31310;
          D.31312 = __s2 + 1;
          D.31313 = *D.31312;
          D.31314 = (int) D.31313;
          __result = D.31311 - D.31314;
          D.31315 = __s2_len > 1;
          D.31305 = __result == 0;
          D.31316 = D.31315 & D.31305;
          if (D.31316 != 0) goto <D.31317>; else goto <D.31318>;
          <D.31317>:
          D.31319 = &MEM[(void *)"EndInvoke" + 2B];
          D.31320 = *D.31319;
          D.31321 = (int) D.31320;
          D.31322 = __s2 + 2;
          D.31323 = *D.31322;
          D.31324 = (int) D.31323;
          __result = D.31321 - D.31324;
          D.31325 = __s2_len > 2;
          D.31305 = __result == 0;
          D.31326 = D.31325 & D.31305;
          if (D.31326 != 0) goto <D.31327>; else goto <D.31328>;
          <D.31327>:
          D.31329 = &MEM[(void *)"EndInvoke" + 3B];
          D.31330 = *D.31329;
          D.31331 = (int) D.31330;
          D.31332 = __s2 + 3;
          D.31333 = *D.31332;
          D.31334 = (int) D.31333;
          __result = D.31331 - D.31334;
          <D.31328>:
          <D.31318>:
          <D.31308>:
        }
        D.26512 = __result;
      }
      iftmp.126 = -D.26512;
      goto <D.31335>;
      <D.31298>:
      iftmp.126 = __builtin_strcmp (name, "EndInvoke");
      <D.31335>:
      D.26513 = iftmp.126;
    }
    if (D.26513 == 0) goto <D.31336>; else goto <D.31337>;
    <D.31336>:
    method.121 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.121);
    D.31338 = mono_compile_method (nm);
    D.31119 = mono_get_addr_from_ftnptr (D.31338);
    return D.31119;
    <D.31337>:
    <D.31295>:
    <D.31156>:
    method.121 = method;
    full_name = mono_method_full_name (method.121, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.31339 = mono_defaults.corlib;
    D.31340 = mono_exception_from_name_msg (D.31339, "System", "InvalidProgramException", msg);
    *jit_ex = D.31340;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.31119 = 0B;
    return D.31119;
  }
  <D.31152>:
  method.121 = method;
  D.31341 = BIT_FIELD_REF <*method.121, 8, 256>;
  D.31342 = D.31341 & 124;
  if (D.31342 == 100) goto <D.31343>; else goto <D.31344>;
  <D.31343>:
  {
    struct WrapperInfo * info;

    method.121 = method;
    info = mono_marshal_get_wrapper_info (method.121);
    D.31345 = info->subtype;
    D.31346 = D.31345 + 4294967278;
    if (D.31346 <= 1) goto <D.31347>; else goto <D.31348>;
    <D.31347>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.31345 = info->subtype;
          D.31349 = D.31345 == 18;
          is_in = (gboolean) D.31349;
          if (is_in != 0) goto <D.31351>; else goto <D.31350>;
          <D.31351>:
          in_tinfo.127 = in_tinfo;
          if (in_tinfo.127 != 0B) goto <D.31353>; else goto <D.31350>;
          <D.31353>:
          in_tinfo.127 = in_tinfo;
          D.31119 = in_tinfo.127->code;
          return D.31119;
          <D.31350>:
          if (is_in == 0) goto <D.31354>; else goto <D.31355>;
          <D.31354>:
          out_tinfo.128 = out_tinfo;
          if (out_tinfo.128 != 0B) goto <D.31357>; else goto <D.31358>;
          <D.31357>:
          out_tinfo.128 = out_tinfo;
          D.31119 = out_tinfo.128->code;
          return D.31119;
          <D.31358>:
          <D.31355>:
          mono_aot_only.129 = mono_aot_only;
          if (mono_aot_only.129 != 0) goto <D.31360>; else goto <D.31361>;
          <D.31360>:
          if (is_in != 0) goto <D.31363>; else goto <D.31364>;
          <D.31363>:
          iftmp.130 = "gsharedvt_trampoline";
          goto <D.31365>;
          <D.31364>:
          iftmp.130 = "gsharedvt_out_trampoline";
          <D.31365>:
          mono_aot_get_trampoline_full (iftmp.130, &tinfo);
          goto <D.31366>;
          <D.31361>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.31366>:
          tinfo.131 = tinfo;
          method.121 = method;
          jinfo = create_jit_info_for_trampoline (method.121, tinfo.131);
          D.31368 = mono_get_root_domain ();
          mono_jit_info_table_add (D.31368, jinfo);
          if (is_in != 0) goto <D.31369>; else goto <D.31370>;
          <D.31369>:
          tinfo.131 = tinfo;
          in_tinfo = tinfo.131;
          goto <D.31371>;
          <D.31370>:
          tinfo.131 = tinfo;
          out_tinfo = tinfo.131;
          <D.31371>:
          tinfo.131 = tinfo;
          D.31119 = tinfo.131->code;
          return D.31119;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.31348>:
  }
  <D.31344>:
  mono_aot_only.129 = mono_aot_only;
  if (mono_aot_only.129 != 0) goto <D.31372>; else goto <D.31373>;
  <D.31372>:
  {
    char * fullname;
    char * msg;

    method.121 = method;
    fullname = mono_method_full_name (method.121, 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.31374 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.31374;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.31119 = 0B;
    return D.31119;
  }
  <D.31373>:
  jit_timer = monoeg_g_timer_new ();
  opt.132 = (unsigned int) opt;
  method.121 = method;
  cfg = mini_method_compile (method.121, opt.132, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.31376 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.31377 = mono_jit_stats.jit_time;
  D.31378 = D.31377 + D.31376;
  mono_jit_stats.jit_time = D.31378;
  monoeg_g_timer_destroy (jit_timer);
  D.31379 = cfg->exception_type;
  switch (D.31379) <default: <D.26541>, case 0: <D.26522>, case 1: <D.26534>, case 3: <D.26530>, case 4: <D.26531>, case 5: <D.26526>, case 6: <D.26525>, case 7: <D.26524>, case 8: <D.26527>, case 9: <D.26532>, case 10: <D.26533>, case 12: <D.26528>, case 13: <D.26538>, case 14: <D.26540>>
  <D.26522>:
  goto <D.26523>;
  <D.26524>:
  <D.26525>:
  <D.26526>:
  <D.26527>:
  <D.26528>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.31380>; else goto <D.31381>;
    <D.31380>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.31382>;
    <D.31381>:
    D.31383 = cfg->exception_ptr;
    if (D.31383 != 0B) goto <D.31384>; else goto <D.31385>;
    <D.31384>:
    D.31383 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.31383);
    goto <D.31386>;
    <D.31385>:
    D.31379 = cfg->exception_type;
    if (D.31379 == 6) goto <D.31387>; else goto <D.31388>;
    <D.31387>:
    D.31389 = cfg->exception_message;
    D.31339 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.31339, "System", "MissingFieldException", D.31389);
    goto <D.31390>;
    <D.31388>:
    D.31379 = cfg->exception_type;
    if (D.31379 == 5) goto <D.31391>; else goto <D.31392>;
    <D.31391>:
    D.31389 = cfg->exception_message;
    D.31339 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.31339, "System", "MissingMethodException", D.31389);
    goto <D.31393>;
    <D.31392>:
    D.31379 = cfg->exception_type;
    if (D.31379 == 7) goto <D.31394>; else goto <D.31395>;
    <D.31394>:
    D.31389 = cfg->exception_message;
    D.31339 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.31339, "System", "TypeLoadException", D.31389);
    goto <D.31396>;
    <D.31395>:
    D.31379 = cfg->exception_type;
    if (D.31379 == 8) goto <D.31397>; else goto <D.31398>;
    <D.31397>:
    D.31389 = cfg->exception_message;
    D.31339 = mono_defaults.corlib;
    ex = mono_exception_from_name_msg (D.31339, "System", "FileNotFoundException", D.31389);
    goto <D.31399>;
    <D.31398>:
    D.31379 = cfg->exception_type;
    if (D.31379 == 12) goto <D.31400>; else goto <D.31401>;
    <D.31400>:
    D.31389 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.31389);
    goto <D.31402>;
    <D.31401>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.31402>:
    <D.31399>:
    <D.31396>:
    <D.31393>:
    <D.31390>:
    <D.31386>:
    <D.31382>:
    goto <D.26523>;
  }
  <D.26530>:
  D.31389 = cfg->exception_message;
  D.31339 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.31339, "System", "InvalidProgramException", D.31389);
  goto <D.26523>;
  <D.26531>:
  D.31389 = cfg->exception_message;
  D.31339 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.31339, "System.Security", "VerificationException", D.31389);
  goto <D.26523>;
  <D.26532>:
  D.31389 = cfg->exception_message;
  D.31339 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.31339, "System", "MethodAccessException", D.31389);
  goto <D.26523>;
  <D.26533>:
  D.31389 = cfg->exception_message;
  D.31339 = mono_defaults.corlib;
  ex = mono_exception_from_name_msg (D.31339, "System", "FieldAccessException", D.31389);
  goto <D.26523>;
  <D.26534>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

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

    exp = cfg->exception_ptr;
    D.31405 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.31405);
    ex = exp;
    goto <D.26523>;
  }
  <D.26540>:
  D.31406 = mono_domain_get ();
  ex = D.31406->out_of_memory_ex;
  goto <D.26523>;
  <D.26541>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.26523>:
  if (ex != 0B) goto <D.31407>; else goto <D.31408>;
  <D.31407>:
  D.31409 = cfg->prof_options;
  D.31410 = D.31409 & 16;
  if (D.31410 != 0) goto <D.31411>; else goto <D.31412>;
  <D.31411>:
  method.121 = method;
  mono_profiler_method_end_jit (method.121, 0B, 1);
  <D.31412>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.31119 = 0B;
  return D.31119;
  <D.31408>:
  mono_loader_lock ();
  {
    int ret;

    D.31413 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.31413);
    if (ret != 0) goto <D.31414>; else goto <D.31415>;
    <D.31414>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31415>:
    D.31416 = ret != 0;
    D.31417 = (long int) D.31416;
    D.31418 = __builtin_expect (D.31417, 0);
    if (D.31418 != 0) goto <D.31419>; else goto <D.31420>;
    <D.31419>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.31420>:
  }
  {
    int ret;

    D.31421 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.31421);
    if (ret != 0) goto <D.31422>; else goto <D.31423>;
    <D.31422>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31423>:
    D.31424 = ret != 0;
    D.31425 = (long int) D.31424;
    D.31426 = __builtin_expect (D.31425, 0);
    if (D.31426 != 0) goto <D.31427>; else goto <D.31428>;
    <D.31427>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.31428>:
  }
  method.121 = method;
  info = lookup_method_inner (target_domain, method.121);
  if (info != 0B) goto <D.31429>; else goto <D.31430>;
  <D.31429>:
  D.31433 = mono_domain_get ();
  if (D.31433 == target_domain) goto <D.31431>; else goto <D.31434>;
  <D.31434>:
  D.31435 = BIT_FIELD_REF <*info, 8, 264>;
  D.31436 = D.31435 & 128;
  if (D.31436 != 0) goto <D.31431>; else goto <D.31432>;
  <D.31431>:
  code = info->code_start;
  <D.31432>:
  <D.31430>:
  if (code == 0B) goto <D.31437>; else goto <D.31438>;
  <D.31437>:
  D.31439 = cfg->jit_info;
  D.31439 = cfg->jit_info;
  D.31440 = D.31439->d.method;
  D.31441 = &target_domain->jit_code_hash;
  mono_internal_hash_table_insert (D.31441, D.31440, D.31439);
  {
    int ret;

    D.31421 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31421);
    if (ret != 0) goto <D.31442>; else goto <D.31443>;
    <D.31442>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31443>:
    D.31444 = ret != 0;
    D.31445 = (long int) D.31444;
    D.31446 = __builtin_expect (D.31445, 0);
    if (D.31446 != 0) goto <D.31447>; else goto <D.31448>;
    <D.31447>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.31448>:
  }
  code = cfg->native_code;
  D.31449 = cfg->generic_sharing_context;
  if (D.31449 != 0B) goto <D.31450>; else goto <D.31451>;
  <D.31450>:
  method.121 = method;
  D.31452 = mono_method_is_generic_sharable (method.121, 0);
  if (D.31452 != 0) goto <D.31453>; else goto <D.31454>;
  <D.31453>:
  D.31455 = mono_stats.generics_shared_methods;
  D.31456 = D.31455 + 1;
  mono_stats.generics_shared_methods = D.31456;
  <D.31454>:
  <D.31451>:
  D.31457 = cfg->gsharedvt;
  if (D.31457 != 0) goto <D.31458>; else goto <D.31459>;
  <D.31458>:
  D.31460 = mono_stats.gsharedvt_methods;
  D.31461 = D.31460 + 1;
  mono_stats.gsharedvt_methods = D.31461;
  <D.31459>:
  goto <D.31462>;
  <D.31438>:
  {
    int ret;

    D.31421 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31421);
    if (ret != 0) goto <D.31463>; else goto <D.31464>;
    <D.31463>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31464>:
    D.31465 = ret != 0;
    D.31466 = (long int) D.31465;
    D.31467 = __builtin_expect (D.31466, 0);
    if (D.31467 != 0) goto <D.31468>; else goto <D.31469>;
    <D.31468>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.31469>:
  }
  <D.31462>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.31470 = mono_jit_stats.allocate_var;
  D.31471 = cfg->stat_allocate_var;
  D.31472 = D.31470 + D.31471;
  mono_jit_stats.allocate_var = D.31472;
  D.31473 = mono_jit_stats.locals_stack_size;
  D.31474 = cfg->stat_locals_stack_size;
  D.31475 = D.31473 + D.31474;
  mono_jit_stats.locals_stack_size = D.31475;
  D.31476 = mono_jit_stats.basic_blocks;
  D.31477 = cfg->stat_basic_blocks;
  D.31478 = D.31476 + D.31477;
  mono_jit_stats.basic_blocks = D.31478;
  D.31479 = mono_jit_stats.max_basic_blocks;
  D.31477 = cfg->stat_basic_blocks;
  D.31480 = MAX_EXPR <D.31479, D.31477>;
  mono_jit_stats.max_basic_blocks = D.31480;
  D.31481 = mono_jit_stats.cil_code_size;
  D.31482 = cfg->stat_cil_code_size;
  D.31483 = D.31481 + D.31482;
  mono_jit_stats.cil_code_size = D.31483;
  D.31484 = mono_jit_stats.regvars;
  D.31485 = cfg->stat_n_regvars;
  D.31486 = D.31484 + D.31485;
  mono_jit_stats.regvars = D.31486;
  D.31487 = mono_jit_stats.inlineable_methods;
  D.31488 = cfg->stat_inlineable_methods;
  D.31489 = D.31487 + D.31488;
  mono_jit_stats.inlineable_methods = D.31489;
  D.31490 = mono_jit_stats.inlined_methods;
  D.31491 = cfg->stat_inlined_methods;
  D.31492 = D.31490 + D.31491;
  mono_jit_stats.inlined_methods = D.31492;
  D.31493 = mono_jit_stats.cas_demand_generation;
  D.31494 = cfg->stat_cas_demand_generation;
  D.31495 = D.31493 + D.31494;
  mono_jit_stats.cas_demand_generation = D.31495;
  D.31496 = mono_jit_stats.code_reallocs;
  D.31497 = cfg->stat_code_reallocs;
  D.31498 = D.31496 + D.31497;
  mono_jit_stats.code_reallocs = D.31498;
  mono_destroy_compile (cfg);
  D.31499 = target_domain->runtime_info;
  D.31500 = MEM[(struct MonoJitDomainInfo *)D.31499].jump_target_hash;
  if (D.31500 != 0B) goto <D.31501>; else goto <D.31502>;
  <D.31501>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        method.121 = method;
        D.31499 = target_domain->runtime_info;
        D.31500 = MEM[(struct MonoJitDomainInfo *)D.31499].jump_target_hash;
        jlist = monoeg_g_hash_table_lookup (D.31500, method.121);
        if (jlist != 0B) goto <D.31503>; else goto <D.31504>;
        <D.31503>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.121 = method;
        patch_info.data.method = method.121;
        method.121 = method;
        D.31499 = target_domain->runtime_info;
        D.31500 = MEM[(struct MonoJitDomainInfo *)D.31499].jump_target_hash;
        monoeg_g_hash_table_remove (D.31500, method.121);
        tmp = jlist->list;
        goto <D.26550>;
        <D.26549>:
        D.31505 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.31505, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.26550>:
        if (tmp != 0B) goto <D.26549>; else goto <D.26551>;
        <D.26551>:
        <D.31504>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.31502>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.31413 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31413);
    if (ret != 0) goto <D.31506>; else goto <D.31507>;
    <D.31506>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31507>:
    D.31508 = ret != 0;
    D.31509 = (long int) D.31508;
    D.31510 = __builtin_expect (D.31509, 0);
    if (D.31510 != 0) goto <D.31511>; else goto <D.31512>;
    <D.31511>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.31512>:
  }
  mono_loader_unlock ();
  method.121 = method;
  D.31111 = method.121->klass;
  vtable = mono_class_vtable (target_domain, D.31111);
  if (vtable == 0B) goto <D.31513>; else goto <D.31514>;
  <D.31513>:
  method.121 = method;
  D.31111 = method.121->klass;
  ex = mono_class_get_exception_for_failure (D.31111);
  D.31515 = ex == 0B;
  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", 6115, "ex");
  <D.31519>:
  *jit_ex = ex;
  D.31119 = 0B;
  return D.31119;
  <D.31514>:
  D.31520 = prof_options & 16;
  if (D.31520 != 0) goto <D.31521>; else goto <D.31522>;
  <D.31521>:
  method.121 = method;
  D.31341 = BIT_FIELD_REF <*method.121, 8, 256>;
  D.31342 = D.31341 & 124;
  if (D.31342 == 24) goto <D.31523>; else goto <D.31524>;
  <D.31523>:
  method.121 = method;
  D.31525 = mono_marshal_method_from_wrapper (method.121);
  if (D.31525 != 0B) goto <D.31526>; else goto <D.31527>;
  <D.31526>:
  method.121 = method;
  D.31528 = mono_marshal_method_from_wrapper (method.121);
  mono_profiler_method_end_jit (D.31528, jinfo, 0);
  <D.31527>:
  <D.31524>:
  method.121 = method;
  mono_profiler_method_end_jit (method.121, jinfo, 0);
  method.121 = method;
  if (prof_method != method.121) goto <D.31529>; else goto <D.31530>;
  <D.31529>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.31530>:
  <D.31522>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.31531>; else goto <D.31532>;
  <D.31531>:
  *jit_ex = ex;
  D.31119 = 0B;
  return D.31119;
  <D.31532>:
  D.31119 = code;
  return D.31119;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.31537;
  unsigned int info_len.133;
  struct GSList * D.31542;
  guint8 * D.31543;
  unsigned int D.31544;
  int D.31545;
  unsigned int info_len.134;
  unsigned int D.31547;
  struct MonoJitInfo * D.31548;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.31537 = info->uw_info;
      if (D.31537 != 0B) goto <D.31538>; else goto <D.31539>;
      <D.31538>:
      uw_info = info->uw_info;
      info_len.133 = info->uw_info_len;
      info_len = info_len.133;
      goto <D.31541>;
      <D.31539>:
      D.31542 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.31542, &info_len);
      <D.31541>:
      jinfo = mono_domain_alloc0 (domain, 48);
      jinfo->d.method = wrapper;
      D.31543 = info->code;
      jinfo->code_start = D.31543;
      D.31544 = info->code_size;
      D.31545 = (int) D.31544;
      jinfo->code_size = D.31545;
      info_len.134 = info_len;
      D.31547 = mono_cache_unwind_info (uw_info, info_len.134);
      jinfo->used_regs = D.31547;
      D.31548 = jinfo;
      return D.31548;
    }
  finally
    {
      info_len = {CLOBBER};
    }
}


mono_jit_find_compiled_method_with_jit_info (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitInfo * * ji)
{
  unsigned int default_opt.135;
  unsigned int D.31552;
  unsigned char D.31561;
  unsigned char D.31562;
  int D.31563;
  int D.31564;
  void * D.31567;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.135 = default_opt;
  D.31552 = default_opt.135 & 512;
  if (D.31552 != 0) goto <D.31553>; else goto <D.31554>;
  <D.31553>:
  target_domain = mono_get_root_domain ();
  goto <D.31555>;
  <D.31554>:
  target_domain = domain;
  <D.31555>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.31556>; else goto <D.31557>;
  <D.31556>:
  if (domain == target_domain) goto <D.31558>; else goto <D.31560>;
  <D.31560>:
  D.31561 = BIT_FIELD_REF <*info, 8, 264>;
  D.31562 = D.31561 & 128;
  if (D.31562 != 0) goto <D.31558>; else goto <D.31559>;
  <D.31558>:
  D.31563 = mono_jit_stats.methods_lookups;
  D.31564 = D.31563 + 1;
  mono_jit_stats.methods_lookups = D.31564;
  if (ji != 0B) goto <D.31565>; else goto <D.31566>;
  <D.31565>:
  *ji = info;
  <D.31566>:
  D.31567 = info->code_start;
  return D.31567;
  <D.31559>:
  <D.31557>:
  if (ji != 0B) goto <D.31568>; else goto <D.31569>;
  <D.31568>:
  *ji = 0B;
  <D.31569>:
  D.31567 = 0B;
  return D.31567;
}


mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.31571;
  long int D.31572;
  long int D.31573;
  int mono_do_single_method_regression.136;
  guint32 D.31579;
  struct MonoMethod * mono_current_single_method.137;
  struct GHashTable * mono_single_method_hash.138;
  struct GHashTable * mono_single_method_hash.139;
  void * D.31587;
  struct GSList * mono_single_method_list.140;
  struct GSList * mono_single_method_list.141;

  D.31571 = method == 0B;
  D.31572 = (long int) D.31571;
  D.31573 = __builtin_expect (D.31572, 0);
  if (D.31573 != 0) goto <D.31574>; else goto <D.31575>;
  <D.31574>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.31575>:
  mono_do_single_method_regression.136 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.136 == 0) goto <D.31577>; else goto <D.31578>;
  <D.31577>:
  D.31579 = default_opt;
  return D.31579;
  <D.31578>:
  mono_current_single_method.137 = mono_current_single_method;
  if (mono_current_single_method.137 == 0B) goto <D.31581>; else goto <D.31582>;
  <D.31581>:
  mono_single_method_hash.138 = mono_single_method_hash;
  if (mono_single_method_hash.138 == 0B) goto <D.31584>; else goto <D.31585>;
  <D.31584>:
  mono_single_method_hash.139 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = mono_single_method_hash.139;
  <D.31585>:
  mono_single_method_hash.138 = mono_single_method_hash;
  D.31587 = monoeg_g_hash_table_lookup (mono_single_method_hash.138, method);
  if (D.31587 == 0B) goto <D.31588>; else goto <D.31589>;
  <D.31588>:
  mono_single_method_hash.138 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.138, method, method, 0);
  mono_single_method_list.140 = mono_single_method_list;
  mono_single_method_list.141 = monoeg_g_slist_prepend (mono_single_method_list.140, method);
  mono_single_method_list = mono_single_method_list.141;
  <D.31589>:
  D.31579 = default_opt;
  return D.31579;
  <D.31582>:
  mono_current_single_method.137 = mono_current_single_method;
  if (method == mono_current_single_method.137) goto <D.31592>; else goto <D.31593>;
  <D.31592>:
  D.31579 = mono_single_method_regression_opt;
  return D.31579;
  <D.31593>:
  D.31579 = default_opt;
  return D.31579;
}


mono_jit_find_compiled_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.31595;

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


mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  void * D.31597;
  struct MonoDomain * D.31598;
  int D.31599;
  int D.31605;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.31597 = mono_arch_ip_from_context (ctx);
  D.31598 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.31598, D.31597);
  D.31599 = mono_arch_is_int_overflow (ctx, info);
  if (D.31599 != 0) goto <D.31600>; else goto <D.31601>;
  <D.31600>:
  exc = mono_get_exception_overflow ();
  goto <D.31602>;
  <D.31601>:
  exc = mono_get_exception_divide_by_zero ();
  <D.31602>:
  if (ji == 0B) goto <D.31603>; else goto <D.31604>;
  <D.31603>:
  D.31605 = mono_chain_signal (_dummy, info, context);
  if (D.31605 != 0) goto <D.31606>; else goto <D.31607>;
  <D.31606>:
  return;
  <D.31607>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31604>:
  mono_arch_handle_exception (ctx, exc);
}


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);
}


mono_sigsegv_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  unsigned int mono_jit_tls_id.142;
  int D.31610;
  int D.31613;
  void * D.31616;
  int D.31617;
  struct MonoDomain * D.31622;
  int D.31624;
  void * D.31627;
  struct MonoDomain * D.31628;
  int D.31629;
  long int D.31634;
  unsigned int D.31636;
  long int fault_addr.143;
  void * D.31639;
  sizetype D.31640;
  sizetype D.31641;
  guint8 * D.31642;
  long int D.31643;
  long int D.31644;
  long int D.31645;
  long unsigned int D.31646;
  int D.31650;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.142 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.142);
  fault_addr = 0B;
  ctx = context;
  D.31610 = mono_arch_is_single_step_event (info, ctx);
  if (D.31610 != 0) goto <D.31611>; else goto <D.31612>;
  <D.31611>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.31612>:
  D.31613 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.31613 != 0) goto <D.31614>; else goto <D.31615>;
  <D.31614>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.31615>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.31616 = info->_sifields._sigfault.si_addr;
  D.31617 = mono_aot_is_pagefault (D.31616);
  if (D.31617 != 0) goto <D.31618>; else goto <D.31619>;
  <D.31618>:
  D.31616 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.31616);
  return;
  <D.31619>:
  D.31622 = mono_domain_get ();
  if (D.31622 == 0B) goto <D.31620>; else goto <D.31623>;
  <D.31623>:
  if (jit_tls == 0B) goto <D.31620>; else goto <D.31621>;
  <D.31620>:
  D.31624 = mono_chain_signal (_dummy, info, context);
  if (D.31624 != 0) goto <D.31625>; else goto <D.31626>;
  <D.31625>:
  return;
  <D.31626>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31621>:
  D.31627 = mono_arch_ip_from_context (ctx);
  D.31628 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.31628, D.31627);
  D.31616 = info->_sifields._sigfault.si_addr;
  D.31629 = mono_handle_soft_stack_ovf (jit_tls, ji, ctx, D.31616);
  if (D.31629 != 0) goto <D.31630>; else goto <D.31631>;
  <D.31630>:
  return;
  <D.31631>:
  fault_addr = info->_sifields._sigfault.si_addr;
  if (fault_addr == 0B) goto <D.31632>; else goto <D.31633>;
  <D.31632>:
  {
    struct MonoContext mctx;

    try
      {
        mono_arch_sigctx_to_monoctx (ctx, &mctx);
        D.31634 = mctx.rsp;
        fault_addr = (void *) D.31634;
      }
    finally
      {
        mctx = {CLOBBER};
      }
  }
  <D.31633>:
  D.31636 = jit_tls->stack_size;
  if (D.31636 != 0) goto <D.31637>; else goto <D.31635>;
  <D.31637>:
  fault_addr.143 = (long int) fault_addr;
  D.31639 = jit_tls->end_of_stack;
  D.31636 = jit_tls->stack_size;
  D.31640 = (sizetype) D.31636;
  D.31641 = -D.31640;
  D.31642 = D.31639 + D.31641;
  D.31643 = (long int) D.31642;
  D.31644 = fault_addr.143 - D.31643;
  D.31645 = ABS_EXPR <D.31644>;
  D.31646 = (long unsigned int) D.31645;
  if (D.31646 <= 65535) goto <D.31647>; else goto <D.31635>;
  <D.31647>:
  D.31616 = info->_sifields._sigfault.si_addr;
  mono_handle_hard_stack_ovf (jit_tls, ji, ctx, D.31616);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6763);
  <D.31635>:
  if (ji == 0B) goto <D.31648>; else goto <D.31649>;
  <D.31648>:
  D.31650 = mono_chain_signal (_dummy, info, context);
  if (D.31650 != 0) goto <D.31651>; else goto <D.31652>;
  <D.31651>:
  return;
  <D.31652>:
  <D.31649>:
  D.31616 = info->_sifields._sigfault.si_addr;
  mono_arch_handle_altstack_exception (ctx, D.31616, 0);
}


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);
}


mini_get_vtable_trampoline (int slot_index)
{
  _Bool D.31654;
  long int D.31655;
  long int D.31656;
  void * * vtable_trampolines.144;
  int D.31663;
  int vtable_trampolines_size.145;
  _Bool D.31667;
  long int D.31668;
  long int D.31669;
  int iftmp.146;
  long unsigned int D.31679;
  long unsigned int D.31680;
  long unsigned int D.31683;
  long unsigned int D.31684;
  _Bool D.31687;
  long int D.31688;
  long int D.31689;
  long unsigned int D.31692;
  long unsigned int D.31693;
  void * * D.31694;
  void * D.31695;
  struct MonoDomain * D.31698;
  long unsigned int D.31699;
  void * D.31700;
  void * D.31701;
  void * D.31702;
  int index;

  index = slot_index + 19;
  D.31654 = slot_index < -19;
  D.31655 = (long int) D.31654;
  D.31656 = __builtin_expect (D.31655, 0);
  if (D.31656 != 0) goto <D.31657>; else goto <D.31658>;
  <D.31657>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.31658>:
  vtable_trampolines.144 = vtable_trampolines;
  if (vtable_trampolines.144 == 0B) goto <D.31659>; else goto <D.31662>;
  <D.31662>:
  D.31663 = slot_index + 19;
  vtable_trampolines_size.145 = vtable_trampolines_size;
  if (D.31663 >= vtable_trampolines_size.145) goto <D.31659>; else goto <D.31660>;
  <D.31659>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31665>; else goto <D.31666>;
    <D.31665>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31666>:
    D.31667 = ret != 0;
    D.31668 = (long int) D.31667;
    D.31669 = __builtin_expect (D.31668, 0);
    if (D.31669 != 0) goto <D.31670>; else goto <D.31671>;
    <D.31670>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.31671>:
  }
  vtable_trampolines.144 = vtable_trampolines;
  if (vtable_trampolines.144 == 0B) goto <D.31672>; else goto <D.31674>;
  <D.31674>:
  vtable_trampolines_size.145 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.145) goto <D.31672>; else goto <D.31673>;
  <D.31672>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.145 = vtable_trampolines_size;
    if (vtable_trampolines_size.145 != 0) goto <D.31676>; else goto <D.31677>;
    <D.31676>:
    vtable_trampolines_size.145 = vtable_trampolines_size;
    iftmp.146 = vtable_trampolines_size.145 * 2;
    goto <D.31678>;
    <D.31677>:
    iftmp.146 = 128;
    <D.31678>:
    new_size = iftmp.146;
    goto <D.26752>;
    <D.26751>:
    new_size = new_size * 2;
    <D.26752>:
    if (new_size <= index) goto <D.26751>; else goto <D.26753>;
    <D.26753>:
    D.31679 = (long unsigned int) new_size;
    D.31680 = D.31679 * 8;
    new_table = monoeg_malloc0 (D.31680);
    vtable_trampolines.144 = vtable_trampolines;
    if (vtable_trampolines.144 != 0B) goto <D.31681>; else goto <D.31682>;
    <D.31681>:
    vtable_trampolines_size.145 = vtable_trampolines_size;
    D.31683 = (long unsigned int) vtable_trampolines_size.145;
    D.31684 = D.31683 * 8;
    vtable_trampolines.144 = vtable_trampolines;
    memcpy (new_table, vtable_trampolines.144, D.31684);
    <D.31682>:
    vtable_trampolines.144 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.144);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.31673>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31685>; else goto <D.31686>;
    <D.31685>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31686>:
    D.31687 = ret != 0;
    D.31688 = (long int) D.31687;
    D.31689 = __builtin_expect (D.31688, 0);
    if (D.31689 != 0) goto <D.31690>; else goto <D.31691>;
    <D.31690>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.31691>:
  }
  <D.31660>:
  vtable_trampolines.144 = vtable_trampolines;
  D.31692 = (long unsigned int) index;
  D.31693 = D.31692 * 8;
  D.31694 = vtable_trampolines.144 + D.31693;
  D.31695 = *D.31694;
  if (D.31695 == 0B) goto <D.31696>; else goto <D.31697>;
  <D.31696>:
  vtable_trampolines.144 = vtable_trampolines;
  D.31692 = (long unsigned int) index;
  D.31693 = D.31692 * 8;
  D.31694 = vtable_trampolines.144 + D.31693;
  D.31698 = mono_get_root_domain ();
  D.31699 = (long unsigned int) slot_index;
  D.31700 = (void *) D.31699;
  D.31701 = mono_create_specific_trampoline (D.31700, 12, D.31698, 0B);
  *D.31694 = D.31701;
  <D.31697>:
  vtable_trampolines.144 = vtable_trampolines;
  D.31692 = (long unsigned int) index;
  D.31693 = D.31692 * 8;
  D.31694 = vtable_trampolines.144 + D.31693;
  D.31702 = *D.31694;
  return D.31702;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mini_get_debug_options ()
{
  struct MonoDebugOptions * D.31704;

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


mini_init (const char * filename, const char * runtime_version)
{
  int D.31706;
  int default_opt_set.147;
  int D.31712;
  unsigned int default_opt.148;
  int D.31714;
  struct MonoCodeManager * global_codeman.149;
  struct MonoCodeManager * global_codeman.150;
  struct GHashTable * jit_icall_name_hash.151;
  int mono_use_imt.152;
  const gchar * D.31723;
  const gchar * D.31726;
  struct MonoDebugOptions * D.31730;
  int D.31731;
  unsigned int default_opt.153;
  unsigned int D.31739;
  const gchar * D.31742;
  int D.31746;
  int mono_aot_only.154;
  struct MonoCodeManager * D.31755;
  void * D.31761;
  void * D.31762;
  void * D.31763;
  int mono_compile_aot.155;
  struct MonoDomain * D.31767;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.31706 = access ("/proc/self/maps", 0);
      if (D.31706 != 0) goto <D.31707>; else goto <D.31708>;
      <D.31707>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.31708>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.147 = default_opt_set;
      if (default_opt_set.147 == 0) goto <D.31710>; else goto <D.31711>;
      <D.31710>:
      D.31712 = mono_parse_default_optimizations (0B);
      default_opt.148 = (unsigned int) D.31712;
      default_opt = default_opt.148;
      <D.31711>:
      D.31714 = mono_amd64_have_tls_get ();
      mono_runtime_set_has_tls_get (D.31714);
      global_codeman.149 = global_codeman;
      if (global_codeman.149 == 0B) goto <D.31716>; else goto <D.31717>;
      <D.31716>:
      global_codeman.150 = mono_code_manager_new ();
      global_codeman = global_codeman.150;
      <D.31717>:
      jit_icall_name_hash.151 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
      jit_icall_name_hash = jit_icall_name_hash.151;
      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.152 = mono_use_imt;
      if (mono_use_imt.152 != 0) goto <D.31721>; else goto <D.31722>;
      <D.31721>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.31722>:
      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.31723 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.31723 != 0B) goto <D.31724>; else goto <D.31725>;
      <D.31724>:
      mini_parse_debug_options ();
      <D.31725>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.31726 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.31726 != 0B) goto <D.31727>; else goto <D.31728>;
      <D.31727>:
      {
        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.31729>;
      <D.31728>:
      D.31730 = mini_get_debug_options ();
      D.31731 = D.31730->gdb;
      if (D.31731 != 0) goto <D.31732>; else goto <D.31733>;
      <D.31732>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.31733>:
      <D.31729>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.31734>; else goto <D.31735>;
      <D.31734>:
      if (0 != 0) goto <D.31736>; else goto <D.31737>;
      <D.31736>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.26976>:
      goto <D.26976>;
      <D.31737>:
      <D.31735>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.153 = default_opt;
      D.31739 = default_opt.153 & 65536;
      if (D.31739 != 0) goto <D.31740>; else goto <D.31741>;
      <D.31740>:
      mono_aot_init ();
      <D.31741>:
      mono_debugger_agent_init ();
      mono_set_generic_sharing_supported (1);
      mono_runtime_install_handlers ();
      mono_threads_install_cleanup (mini_thread_cleanup);
      D.31742 = monoeg_g_getenv ("MONO_DISABLE_PENDING_EXCEPTIONS");
      if (D.31742 != 0B) goto <D.31743>; else goto <D.31744>;
      <D.31743>:
      printf ("MONO_DISABLE_PENDING_EXCEPTIONS env var set.\n");
      goto <D.31745>;
      <D.31744>:
      check_for_pending_exc = 0;
      mono_threads_install_notify_pending_exc (mono_arch_notify_pending_exc);
      <D.31745>:
      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.31746 = debug_options.collect_pagefault_stats;
      if (D.31746 != 0) goto <D.31747>; else goto <D.31748>;
      <D.31747>:
      mono_aot_set_make_unreadable (1);
      <D.31748>:
      if (runtime_version != 0B) goto <D.31749>; else goto <D.31750>;
      <D.31749>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.31751>;
      <D.31750>:
      domain = mono_init_from_assembly (filename, filename);
      <D.31751>:
      mono_aot_only.154 = mono_aot_only;
      if (mono_aot_only.154 != 0) goto <D.31753>; else goto <D.31754>;
      <D.31753>:
      D.31755 = domain->code_mp;
      mono_code_manager_set_read_only (D.31755);
      mono_marshal_use_aot_wrappers (1);
      <D.31754>:
      mono_use_imt.152 = mono_use_imt;
      if (mono_use_imt.152 != 0) goto <D.31756>; else goto <D.31757>;
      <D.31756>:
      mono_aot_only.154 = mono_aot_only;
      if (mono_aot_only.154 != 0) goto <D.31758>; else goto <D.31759>;
      <D.31758>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.31760>;
      <D.31759>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.31760>:
      <D.31757>:
      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.31761 = mono_get_throw_exception ();
      register_dyn_icall (D.31761, "mono_arch_throw_exception", "void object", 1);
      D.31762 = mono_get_rethrow_exception ();
      register_dyn_icall (D.31762, "mono_arch_rethrow_exception", "void object", 1);
      D.31763 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.31763, "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 (688, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, "mono_fconv_u8", 0);
      register_opcode_emulation (687, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 0);
      register_opcode_emulation (716, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, "mono_fconv_ovf_i8", 0);
      register_opcode_emulation (717, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, "mono_fconv_ovf_u8", 0);
      register_opcode_emulation (592, "__emul_iconv_to_r_un", "double int32", mono_conv_to_r8_un, "mono_conv_to_r8_un", 0);
      register_opcode_emulation (677, "__emul_frem", "double double double", fmod, "fmod", 0);
      register_opcode_emulation (731, "__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_simd_intrinsics_init ();
      mono_tasklets_init ();
      mono_compile_aot.155 = mono_compile_aot;
      if (mono_compile_aot.155 != 0) goto <D.31765>; else goto <D.31766>;
      <D.31765>:
      mono_runtime_set_no_exec (1);
      <D.31766>:
      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.31767 = domain;
      return D.31767;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.31772;
  unsigned int D.31773;
  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.31770>; else goto <D.31771>;
  <D.31770>:
  thread->jit_data = jit_tls;
  <D.31771>:
  D.31772 = mono_profiler_get_events ();
  D.31773 = D.31772 & 32768;
  if (D.31773 != 0) goto <D.31774>; else goto <D.31775>;
  <D.31774>:
  mono_runtime_setup_stat_profiler ();
  <D.31775>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T3627>) (struct MonoObject *) mono_thread_attach_aborted_cb.156;

  mono_thread_attach_aborted_cb.156 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.156 != 0B) goto <D.31777>; else goto <D.31778>;
  <D.31777>:
  mono_thread_attach_aborted_cb.156 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.156 (obj);
  goto <D.31779>;
  <D.31778>:
  mono_thread_abort (obj);
  <D.31779>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.31783;
  struct MonoVTable * D.31785;
  struct MonoClass * D.31786;
  struct MonoClass * D.31787;

  D.31783 = mono_runtime_unhandled_exception_policy_get ();
  if (D.31783 == 0) goto <D.31780>; else goto <D.31784>;
  <D.31784>:
  D.31785 = obj->vtable;
  D.31786 = D.31785->klass;
  D.31787 = mono_defaults.threadabortexception_class;
  if (D.31786 == D.31787) goto <D.31780>; else goto <D.31781>;
  <D.31780>:
  mono_thread_exit ();
  goto <D.31782>;
  <D.31781>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.31782>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.157;
  void * D.31791;
  void (*<T3627>) (struct MonoObject *) abort_func.158;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.157 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.157);
  if (jit_tls != 0B) goto <D.31789>; else goto <D.31790>;
  <D.31789>:
  D.31791 = jit_tls;
  return D.31791;
  <D.31790>:
  jit_tls = monoeg_malloc0 (840);
  abort_func.158 = (void (*<T3627>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.158;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (72);
  jit_tls->first_lmf = lmf;
  mono_lmf = lmf;
  mono_set_lmf_addr (&mono_lmf);
  mono_setup_altstack (jit_tls);
  D.31791 = jit_tls;
  return D.31791;
}


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

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


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.31795;
  int D.31796;
  _Bool D.31797;

  D.31796 = pthread_setspecific (key, value);
  D.31797 = D.31796 == 0;
  D.31795 = (int) D.31797;
  return D.31795;
}


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.31799>; else goto <D.31800>;
  <D.31799>:
  thread->jit_data = jit_tls;
  <D.31800>:
  mono_arch_cpu_init ();
}


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  void * obj.160;
  short unsigned int D.31804;
  int D.31805;
  int D.31806;
  unsigned char D.31809;
  unsigned char D.31810;
  struct MonoObject * D.31813;
  union mono_mutex_t * D.31814;
  _Bool D.31817;
  long int D.31818;
  long int D.31819;
  struct GHashTable * D.31822;
  _Bool D.31825;
  long int D.31826;
  long int D.31827;
  <unnamed type> D.31832;
  struct MonoClass * D.31835;
  unsigned char D.31836;
  struct MonoException * D.31841;
  struct MonoException * D.31843;
  struct MonoVTable * D.31844;
  struct MonoVTable * D.31845;
  _Bool D.31846;
  long int D.31847;
  long int D.31848;
  unsigned char D.31851;
  short unsigned int D.31854;
  unsigned int D.31855;
  unsigned int D.31856;
  int mono_aot_only.161;
  unsigned int default_opt.162;
  unsigned int D.31866;
  void * D.31867;
  void * D.31868;
  struct MonoException * jit_ex.163;
  _Bool D.31872;
  long int D.31873;
  long int D.31874;
  int D.31879;
  void * D.31880;
  int D.31885;
  unsigned char D.31886;
  unsigned char D.31889;
  struct MonoClass * D.31892;
  int D.31893;
  short unsigned int D.31896;
  int D.31897;
  unsigned char D.31900;
  unsigned char D.31901;
  struct MonoDynCallInfo * D.31905;
  struct MonoDynCallInfo * D.31906;
  unsigned char D.31909;
  int D.31910;
  struct MonoClass * D.31911;
  struct MonoClass * D.31912;
  int D.31913;
  struct MonoClass * D.31916;
  struct MonoClass * D.31917;
  void * D.31920;
  _Bool D.31923;
  long int D.31924;
  long int D.31925;
  _Bool D.31933;
  long int D.31934;
  long int D.31935;
  void * D.31938;
  struct MonoException * D.31941;
  struct MonoObject * D.31942;
  void (*<T3299>) (void *, struct MonoObject * *, void *) dyn_runtime_invoke.164;
  void * D.31953;
  void (*<T3299>) (void *, struct MonoObject * *, void *) dyn_runtime_invoke.165;
  short unsigned int D.31955;
  int D.31956;
  <unnamed-unsigned:1> D.31957;
  int D.31958;
  int D.31959;
  long unsigned int D.31960;
  long unsigned int D.31961;
  unsigned char D.31962;
  unsigned char D.31963;
  int pindex.166;
  long unsigned int D.31967;
  long unsigned int D.31968;
  void * * D.31969;
  unsigned char D.31970;
  unsigned char D.31971;
  int pindex.167;
  long unsigned int D.31975;
  long unsigned int D.31976;
  void * * D.31977;
  long unsigned int D.31978;
  long unsigned int D.31979;
  void * D.31980;
  int D.31985;
  unsigned char D.31987;
  int pindex.168;
  long unsigned int D.31989;
  long unsigned int D.31990;
  void * * D.31991;
  int pindex.169;
  long unsigned int D.31993;
  long unsigned int D.31994;
  void * * D.31995;
  void * * D.31996;
  void * D.31997;
  struct MonoClass * D.31998;
  guint8[128] * retval.170;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T3294>) (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 ();
  obj.160 = obj;
  if (obj.160 == 0B) goto <D.31802>; else goto <D.31803>;
  <D.31802>:
  D.31804 = method->flags;
  D.31805 = (int) D.31804;
  D.31806 = D.31805 & 16;
  if (D.31806 == 0) goto <D.31807>; else goto <D.31808>;
  <D.31807>:
  D.31809 = BIT_FIELD_REF <*method, 8, 256>;
  D.31810 = D.31809 & 252;
  if (D.31810 == 0) goto <D.31811>; else goto <D.31812>;
  <D.31811>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.31813 = 0B;
  return D.31813;
  <D.31812>:
  <D.31808>:
  <D.31803>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.31814 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31814);
    if (ret != 0) goto <D.31815>; else goto <D.31816>;
    <D.31815>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31816>:
    D.31817 = ret != 0;
    D.31818 = (long int) D.31817;
    D.31819 = __builtin_expect (D.31818, 0);
    if (D.31819 != 0) goto <D.31820>; else goto <D.31821>;
    <D.31820>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.31821>:
  }
  D.31822 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.31822, method);
  {
    int ret;

    D.31814 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31814);
    if (ret != 0) goto <D.31823>; else goto <D.31824>;
    <D.31823>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31824>:
    D.31825 = ret != 0;
    D.31826 = (long int) D.31825;
    D.31827 = __builtin_expect (D.31826, 0);
    if (D.31827 != 0) goto <D.31828>; else goto <D.31829>;
    <D.31828>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.31829>:
  }
  if (info == 0B) goto <D.31830>; else goto <D.31831>;
  <D.31830>:
  D.31832 = mono_security_get_mode ();
  if (D.31832 == 1) goto <D.31833>; else goto <D.31834>;
  <D.31833>:
  D.31835 = method->klass;
  mono_class_setup_vtable (D.31835);
  D.31835 = method->klass;
  D.31836 = D.31835->exception_type;
  if (D.31836 != 0) goto <D.31837>; else goto <D.31838>;
  <D.31837>:
  if (exc != 0B) goto <D.31839>; else goto <D.31840>;
  <D.31839>:
  D.31835 = method->klass;
  D.31841 = mono_class_get_exception_for_failure (D.31835);
  *exc = D.31841;
  goto <D.31842>;
  <D.31840>:
  D.31835 = method->klass;
  D.31843 = mono_class_get_exception_for_failure (D.31835);
  mono_raise_exception (D.31843);
  <D.31842>:
  D.31813 = 0B;
  return D.31813;
  <D.31838>:
  <D.31834>:
  info = monoeg_malloc0 (48);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.31835 = method->klass;
  D.31844 = mono_class_vtable_full (domain, D.31835, 1);
  info->vtable = D.31844;
  D.31845 = info->vtable;
  D.31846 = D.31845 == 0B;
  D.31847 = (long int) D.31846;
  D.31848 = __builtin_expect (D.31847, 0);
  if (D.31848 != 0) goto <D.31849>; else goto <D.31850>;
  <D.31849>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.31850>:
  callee = method;
  D.31835 = method->klass;
  D.31851 = D.31835->rank;
  if (D.31851 != 0) goto <D.31852>; else goto <D.31853>;
  <D.31852>:
  D.31854 = method->iflags;
  D.31855 = (unsigned int) D.31854;
  D.31856 = D.31855 & 4097;
  if (D.31856 == 4097) goto <D.31857>; else goto <D.31858>;
  <D.31857>:
  mono_aot_only.161 = mono_aot_only;
  if (mono_aot_only.161 != 0) goto <D.31860>; else goto <D.31861>;
  <D.31860>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.31862>;
  <D.31861>:
  callee = 0B;
  <D.31862>:
  <D.31858>:
  <D.31853>:
  if (callee != 0B) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.162 = default_opt;
        D.31866 = mono_get_optimizations_for_method (callee, default_opt.162);
        D.31867 = mono_jit_compile_method_with_opt (callee, D.31866, &jit_ex);
        info->compiled_method = D.31867;
        D.31868 = info->compiled_method;
        if (D.31868 == 0B) goto <D.31869>; else goto <D.31870>;
        <D.31869>:
        monoeg_g_free (info);
        jit_ex.163 = jit_ex;
        D.31872 = jit_ex.163 == 0B;
        D.31873 = (long int) D.31872;
        D.31874 = __builtin_expect (D.31873, 0);
        if (D.31874 != 0) goto <D.31875>; else goto <D.31876>;
        <D.31875>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.31876>:
        if (exc != 0B) goto <D.31877>; else goto <D.31878>;
        <D.31877>:
        jit_ex.163 = jit_ex;
        *exc = jit_ex.163;
        D.31813 = 0B;
        return D.31813;
        <D.31878>:
        jit_ex.163 = jit_ex;
        mono_raise_exception (jit_ex.163);
        <D.31870>:
        D.31879 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.31868 = info->compiled_method;
        D.31880 = mini_add_method_trampoline (0B, callee, D.31868, D.31879, 0);
        info->compiled_method = D.31880;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.31881>;
  <D.31864>:
  info->compiled_method = 0B;
  <D.31881>:
  mono_aot_only.161 = mono_aot_only;
  if (mono_aot_only.161 != 0) goto <D.31882>; else goto <D.31884>;
  <D.31884>:
  D.31885 = debug_options.dyn_runtime_invoke;
  if (D.31885 != 0) goto <D.31882>; else goto <D.31883>;
  <D.31882>:
  {
    struct MonoType * ret_type;
    struct MonoMethodSignature * sig;
    gboolean supported;
    int i;

    sig = mono_method_signature (method);
    supported = 1;
    D.31809 = BIT_FIELD_REF <*method, 8, 256>;
    D.31886 = D.31809 & 128;
    if (D.31886 != 0) goto <D.31887>; else goto <D.31888>;
    <D.31887>:
    sig = mono_marshal_get_string_ctor_signature (method);
    <D.31888>:
    i = 0;
    goto <D.26663>;
    <D.26662>:
    {
      struct MonoType * t;

      t = sig->params[i];
      D.31889 = t->type;
      if (D.31889 == 21) goto <D.31890>; else goto <D.31891>;
      <D.31890>:
      D.31892 = mono_class_from_mono_type (t);
      D.31893 = mono_class_is_nullable (D.31892);
      if (D.31893 != 0) goto <D.31894>; else goto <D.31895>;
      <D.31894>:
      supported = 0;
      <D.31895>:
      <D.31891>:
    }
    i = i + 1;
    <D.26663>:
    D.31896 = sig->param_count;
    D.31897 = (int) D.31896;
    if (D.31897 > i) goto <D.26662>; else goto <D.26664>;
    <D.26664>:
    D.31835 = method->klass;
    D.31900 = BIT_FIELD_REF <*D.31835, 8, 272>;
    D.31901 = D.31900 & 128;
    if (D.31901 != 0) goto <D.31898>; else goto <D.31902>;
    <D.31902>:
    D.31868 = info->compiled_method;
    if (D.31868 == 0B) goto <D.31898>; else goto <D.31899>;
    <D.31898>:
    supported = 0;
    <D.31899>:
    if (supported != 0) goto <D.31903>; else goto <D.31904>;
    <D.31903>:
    D.31905 = mono_arch_dyn_call_prepare (sig);
    info->dyn_call_info = D.31905;
    <D.31904>:
    ret_type = sig->ret;
    D.31906 = info->dyn_call_info;
    if (D.31906 != 0B) goto <D.31907>; else goto <D.31908>;
    <D.31907>:
    D.31909 = ret_type->type;
    D.31910 = (int) D.31909;
    switch (D.31910) <default: <D.26689>, case 1: <D.26665>, case 2: <D.26677>, case 3: <D.26678>, case 4: <D.26667>, case 5: <D.26668>, case 6: <D.26669>, case 7: <D.26670>, case 8: <D.26671>, case 9: <D.26672>, case 10: <D.26675>, case 11: <D.26676>, case 12: <D.26679>, case 13: <D.26680>, case 14: <D.26682>, case 15: <D.26681>, case 17: <D.26688>, case 18: <D.26683>, case 20: <D.26684>, case 21: <D.26687>, case 24: <D.26673>, case 25: <D.26674>, case 28: <D.26686>, case 29: <D.26685>>
    <D.26665>:
    goto <D.26666>;
    <D.26667>:
    <D.26668>:
    <D.26669>:
    <D.26670>:
    <D.26671>:
    <D.26672>:
    <D.26673>:
    <D.26674>:
    <D.26675>:
    <D.26676>:
    <D.26677>:
    <D.26678>:
    <D.26679>:
    <D.26680>:
    D.31911 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.31911;
    goto <D.26666>;
    <D.26681>:
    D.31912 = mono_defaults.int_class;
    info->ret_box_class = D.31912;
    goto <D.26666>;
    <D.26682>:
    <D.26683>:
    <D.26684>:
    <D.26685>:
    <D.26686>:
    goto <D.26666>;
    <D.26687>:
    D.31913 = mono_type_is_reference (ret_type);
    if (D.31913 == 0) goto <D.31914>; else goto <D.31915>;
    <D.31914>:
    D.31916 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.31916;
    <D.31915>:
    goto <D.26666>;
    <D.26688>:
    D.31917 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.31917;
    goto <D.26666>;
    <D.26689>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6569);
    <D.26666>:
    <D.31908>:
  }
  <D.31883>:
  D.31906 = info->dyn_call_info;
  if (D.31906 == 0B) goto <D.31918>; else goto <D.31919>;
  <D.31918>:
  D.31920 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.31920;
  <D.31919>:
  {
    int ret;

    D.31814 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31814);
    if (ret != 0) goto <D.31921>; else goto <D.31922>;
    <D.31921>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31922>:
    D.31923 = ret != 0;
    D.31924 = (long int) D.31923;
    D.31925 = __builtin_expect (D.31924, 0);
    if (D.31925 != 0) goto <D.31926>; else goto <D.31927>;
    <D.31926>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.31927>:
  }
  D.31822 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.31822, method);
  if (info2 != 0B) goto <D.31928>; else goto <D.31929>;
  <D.31928>:
  monoeg_g_free (info);
  info = info2;
  goto <D.31930>;
  <D.31929>:
  D.31822 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.31822, method, info, 0);
  <D.31930>:
  {
    int ret;

    D.31814 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31814);
    if (ret != 0) goto <D.31931>; else goto <D.31932>;
    <D.31931>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31932>:
    D.31933 = ret != 0;
    D.31934 = (long int) D.31933;
    D.31935 = __builtin_expect (D.31934, 0);
    if (D.31935 != 0) goto <D.31936>; else goto <D.31937>;
    <D.31936>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6587, "ret == 0");
    <D.31937>:
  }
  <D.31831>:
  D.31938 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T3294>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.31938;
  if (exc != 0B) goto <D.31939>; else goto <D.31940>;
  <D.31939>:
  D.31845 = info->vtable;
  D.31941 = mono_runtime_class_init_full (D.31845, 0);
  *exc = D.31941;
  D.31942 = *exc;
  if (D.31942 != 0B) goto <D.31943>; else goto <D.31944>;
  <D.31943>:
  D.31813 = 0B;
  return D.31813;
  <D.31944>:
  goto <D.31945>;
  <D.31940>:
  D.31845 = info->vtable;
  mono_runtime_class_init (D.31845);
  <D.31945>:
  if (exc != 0B) goto <D.31946>; else goto <D.31947>;
  <D.31946>:
  *exc = 0B;
  <D.31947>:
  D.31906 = info->dyn_call_info;
  if (D.31906 != 0B) goto <D.31948>; else goto <D.31949>;
  <D.31948>:
  {
    struct MonoMethodSignature * sig;
    void * * args;
    static void (*RuntimeInvokeDynamicFunction) (void *, struct MonoObject * *, void *) dyn_runtime_invoke;
    int i;
    int pindex;
    guint8 buf[128];
    guint8 retval[128];

    try
      {
        sig = mono_method_signature (method);
        dyn_runtime_invoke.164 = dyn_runtime_invoke;
        if (dyn_runtime_invoke.164 == 0B) goto <D.31951>; else goto <D.31952>;
        <D.31951>:
        invoke = mono_marshal_get_runtime_invoke_dynamic ();
        D.31953 = mono_jit_compile_method (invoke);
        dyn_runtime_invoke.165 = (void (*<T3299>) (void *, struct MonoObject * *, void *)) D.31953;
        dyn_runtime_invoke = dyn_runtime_invoke.165;
        <D.31952>:
        D.31955 = sig->param_count;
        D.31956 = (int) D.31955;
        D.31957 = sig->hasthis;
        D.31958 = (int) D.31957;
        D.31959 = D.31956 + D.31958;
        D.31960 = (long unsigned int) D.31959;
        D.31961 = D.31960 * 8;
        args = __builtin_alloca (D.31961);
        pindex = 0;
        D.31962 = BIT_FIELD_REF <*sig, 8, 112>;
        D.31963 = D.31962 & 64;
        if (D.31963 != 0) goto <D.31964>; else goto <D.31965>;
        <D.31964>:
        pindex.166 = pindex;
        pindex = pindex.166 + 1;
        D.31967 = (long unsigned int) pindex.166;
        D.31968 = D.31967 * 8;
        D.31969 = args + D.31968;
        *D.31969 = &obj;
        <D.31965>:
        i = 0;
        goto <D.26701>;
        <D.26700>:
        {
          struct MonoType * t;

          t = sig->params[i];
          D.31970 = BIT_FIELD_REF <*t, 8, 88>;
          D.31971 = D.31970 & 64;
          if (D.31971 != 0) goto <D.31972>; else goto <D.31973>;
          <D.31972>:
          pindex.167 = pindex;
          pindex = pindex.167 + 1;
          D.31975 = (long unsigned int) pindex.167;
          D.31976 = D.31975 * 8;
          D.31977 = args + D.31976;
          D.31978 = (long unsigned int) i;
          D.31979 = D.31978 * 8;
          D.31980 = params + D.31979;
          *D.31977 = D.31980;
          goto <D.31981>;
          <D.31973>:
          D.31985 = mono_type_is_reference (t);
          if (D.31985 != 0) goto <D.31982>; else goto <D.31986>;
          <D.31986>:
          D.31987 = t->type;
          if (D.31987 == 15) goto <D.31982>; else goto <D.31983>;
          <D.31982>:
          pindex.168 = pindex;
          pindex = pindex.168 + 1;
          D.31989 = (long unsigned int) pindex.168;
          D.31990 = D.31989 * 8;
          D.31991 = args + D.31990;
          D.31978 = (long unsigned int) i;
          D.31979 = D.31978 * 8;
          D.31980 = params + D.31979;
          *D.31991 = D.31980;
          goto <D.31984>;
          <D.31983>:
          pindex.169 = pindex;
          pindex = pindex.169 + 1;
          D.31993 = (long unsigned int) pindex.169;
          D.31994 = D.31993 * 8;
          D.31995 = args + D.31994;
          D.31978 = (long unsigned int) i;
          D.31979 = D.31978 * 8;
          D.31996 = params + D.31979;
          D.31997 = *D.31996;
          *D.31995 = D.31997;
          <D.31984>:
          <D.31981>:
        }
        i = i + 1;
        <D.26701>:
        D.31955 = sig->param_count;
        D.31956 = (int) D.31955;
        if (D.31956 > i) goto <D.26700>; else goto <D.26702>;
        <D.26702>:
        D.31906 = info->dyn_call_info;
        mono_arch_start_dyn_call (D.31906, args, &retval, &buf, 128);
        dyn_runtime_invoke.164 = dyn_runtime_invoke;
        D.31868 = info->compiled_method;
        dyn_runtime_invoke.164 (&buf, exc, D.31868);
        D.31906 = info->dyn_call_info;
        mono_arch_finish_dyn_call (D.31906, &buf);
        D.31998 = info->ret_box_class;
        if (D.31998 != 0B) goto <D.31999>; else goto <D.32000>;
        <D.31999>:
        D.31998 = info->ret_box_class;
        D.31813 = mono_value_box (domain, D.31998, &retval);
        return D.31813;
        <D.32000>:
        retval.170 = &retval;
        D.31813 = MEM[(struct MonoObject * *)retval.170];
        return D.31813;
      }
    finally
      {
        buf = {CLOBBER};
        retval = {CLOBBER};
      }
  }
  <D.31949>:
  D.31868 = info->compiled_method;
  obj.160 = obj;
  D.31813 = runtime_invoke (obj.160, params, exc, D.31868);
  return D.31813;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.32007;
  struct GHashTable * D.32008;
  struct GHashTable * D.32011;
  struct GHashTable * D.32014;
  struct GHashTable * D.32017;
  struct GHashTable * D.32018;
  struct GHashTable * D.32019;
  struct GHashTable * D.32020;
  struct GHashTable * D.32021;
  struct GHashTable * D.32024;
  struct GHashTable * D.32025;
  struct GHashTable * D.32026;
  struct GHashTable * D.32027;
  void * D.32028;
  struct GHashTable * D.32031;
  void * D.32034;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.32007 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.32007, delete_jump_list, 0B);
  D.32007 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.32007);
  D.32008 = info->jump_target_got_slot_hash;
  if (D.32008 != 0B) goto <D.32009>; else goto <D.32010>;
  <D.32009>:
  D.32008 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.32008, delete_got_slot_list, 0B);
  D.32008 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.32008);
  <D.32010>:
  D.32011 = info->dynamic_code_hash;
  if (D.32011 != 0B) goto <D.32012>; else goto <D.32013>;
  <D.32012>:
  D.32011 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.32011, dynamic_method_info_free, 0B);
  D.32011 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.32011);
  <D.32013>:
  D.32014 = info->method_code_hash;
  if (D.32014 != 0B) goto <D.32015>; else goto <D.32016>;
  <D.32015>:
  D.32014 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.32014);
  <D.32016>:
  D.32017 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32017);
  D.32018 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32018);
  D.32019 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32019);
  D.32020 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32020);
  D.32021 = info->static_rgctx_trampoline_hash;
  if (D.32021 != 0B) goto <D.32022>; else goto <D.32023>;
  <D.32022>:
  D.32021 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32021);
  <D.32023>:
  D.32024 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.32024);
  D.32025 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.32025);
  D.32026 = info->seq_points;
  monoeg_g_hash_table_destroy (D.32026);
  D.32027 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.32027);
  D.32028 = info->agent_info;
  if (D.32028 != 0B) goto <D.32029>; else goto <D.32030>;
  <D.32029>:
  mono_debugger_agent_free_domain_info (domain);
  <D.32030>:
  D.32031 = info->gsharedvt_arg_tramp_hash;
  if (D.32031 != 0B) goto <D.32032>; else goto <D.32033>;
  <D.32032>:
  D.32031 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.32031);
  <D.32033>:
  D.32034 = domain->runtime_info;
  monoeg_g_free (D.32034);
  domain->runtime_info = 0B;
}


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

  di = value;
  D.32035 = di->code_mp;
  mono_code_manager_destroy (D.32035);
  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.32036;
  struct MonoJumpList * jlist;

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


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.32037;
  struct GHashTable * D.32038;
  struct GHashTable * D.32039;
  struct GHashTable * D.32040;
  struct GHashTable * D.32041;
  struct GHashTable * D.32042;
  struct GHashTable * D.32043;
  struct GHashTable * D.32044;
  struct GHashTable * D.32045;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (392);
  D.32037 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.32037;
  D.32038 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.32038;
  D.32039 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.32039;
  D.32040 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.32040;
  D.32041 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.32041;
  D.32042 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.32042;
  D.32043 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.32043;
  D.32044 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.32044;
  D.32045 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.32045;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.32046;
  int D.32047;
  int i;
  struct MonoSeqPointInfo * info;

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

    sp = &info->seq_points[i];
    D.32046 = sp->next;
    monoeg_g_free (D.32046);
  }
  i = i + 1;
  <D.26962>:
  D.32047 = info->len;
  if (D.32047 > i) goto <D.26961>; else goto <D.26963>;
  <D.26963>:
  monoeg_g_free (info);
}


runtime_invoke_info_free (void * value)
{
  struct MonoDynCallInfo * D.32048;
  struct RuntimeInvokeInfo * info;

  info = value;
  D.32048 = info->dyn_call_info;
  if (D.32048 != 0B) goto <D.32049>; else goto <D.32050>;
  <D.32049>:
  D.32048 = info->dyn_call_info;
  mono_arch_dyn_call_free (D.32048);
  <D.32050>:
  monoeg_g_free (info);
}


mono_jit_create_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  short unsigned int D.32051;
  int D.32052;
  int D.32053;
  struct MonoMethodSignature * D.32056;
  short unsigned int D.32057;
  void * D.32060;
  int D.32064;
  struct MonoMethodSignature * D.32066;
  unsigned char D.32067;
  unsigned char D.32068;
  struct MonoClass * D.32070;
  unsigned char D.32071;
  unsigned char D.32072;
  struct MonoClass * D.32074;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.32051 = method->flags;
  D.32052 = (int) D.32051;
  D.32053 = D.32052 & 64;
  if (D.32053 != 0) goto <D.32054>; else goto <D.32055>;
  <D.32054>:
  D.32056 = mono_method_signature (method);
  D.32057 = D.32056->generic_param_count;
  if (D.32057 != 0) goto <D.32058>; else goto <D.32059>;
  <D.32058>:
  D.32060 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.32060;
  <D.32059>:
  <D.32055>:
  D.32051 = method->flags;
  D.32052 = (int) D.32051;
  D.32064 = D.32052 & 1024;
  if (D.32064 != 0) goto <D.32061>; else goto <D.32065>;
  <D.32065>:
  D.32066 = mono_method_signature (method);
  D.32067 = BIT_FIELD_REF <*D.32066, 8, 112>;
  D.32068 = D.32067 & 64;
  if (D.32068 != 0) goto <D.32069>; else goto <D.32062>;
  <D.32069>:
  D.32070 = method->klass;
  D.32071 = BIT_FIELD_REF <*D.32070, 8, 272>;
  D.32072 = D.32071 & 64;
  if (D.32072 != 0) goto <D.32061>; else goto <D.32073>;
  <D.32073>:
  D.32070 = method->klass;
  D.32074 = mono_defaults.object_class;
  if (D.32070 == D.32074) goto <D.32061>; else goto <D.32062>;
  <D.32061>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.32063>;
  <D.32062>:
  addr = mono_compile_method (method);
  <D.32063>:
  D.32060 = mono_get_addr_from_ftnptr (addr);
  return D.32060;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.32076;
  unsigned char D.32077;
  _Bool D.32078;
  long int D.32079;
  long int D.32080;
  union mono_mutex_t * D.32083;
  _Bool D.32086;
  long int D.32087;
  long int D.32088;
  _Bool D.32093;
  long int D.32094;
  long int D.32095;
  _Bool D.32102;
  long int D.32103;
  long int D.32104;
  void * D.32107;
  struct GHashTable * D.32108;
  struct MonoInternalHashTable * D.32109;
  struct GHashTable * D.32110;
  struct GHashTable * D.32111;
  struct GHashTable * D.32112;
  struct MonoJumpList * jlist.171;
  struct MonoJitInfo * D.32114;
  void * D.32115;
  int D.32118;
  sizetype D.32119;
  guint8 * D.32120;
  void * D.32123;
  struct GSList * D.32124;
  struct GSList * D.32125;
  int D.32126;
  _Bool D.32129;
  long int D.32130;
  long int D.32131;
  int D.32134;
  unsigned char D.32137;
  unsigned char D.32138;
  struct MonoClass * D.32141;
  struct MonoType * D.32142;
  const char * D.32143;
  struct MonoCodeManager * D.32146;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.32076 = BIT_FIELD_REF <*method, 8, 264>;
      D.32077 = D.32076 & 2;
      D.32078 = D.32077 == 0;
      D.32079 = (long int) D.32078;
      D.32080 = __builtin_expect (D.32079, 0);
      if (D.32080 != 0) goto <D.32081>; else goto <D.32082>;
      <D.32081>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.32082>:
      {
        int ret;

        D.32083 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.32083);
        if (ret != 0) goto <D.32084>; else goto <D.32085>;
        <D.32084>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.32085>:
        D.32086 = ret != 0;
        D.32087 = (long int) D.32086;
        D.32088 = __builtin_expect (D.32087, 0);
        if (D.32088 != 0) goto <D.32089>; else goto <D.32090>;
        <D.32089>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.32090>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.32083 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.32083);
        if (ret != 0) goto <D.32091>; else goto <D.32092>;
        <D.32091>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.32092>:
        D.32093 = ret != 0;
        D.32094 = (long int) D.32093;
        D.32095 = __builtin_expect (D.32094, 0);
        if (D.32095 != 0) goto <D.32096>; else goto <D.32097>;
        <D.32096>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.32097>:
      }
      if (ji == 0B) goto <D.32098>; else goto <D.32099>;
      <D.32098>:
      return;
      <D.32099>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.32083 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.32083);
        if (ret != 0) goto <D.32100>; else goto <D.32101>;
        <D.32100>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.32101>:
        D.32102 = ret != 0;
        D.32103 = (long int) D.32102;
        D.32104 = __builtin_expect (D.32103, 0);
        if (D.32104 != 0) goto <D.32105>; else goto <D.32106>;
        <D.32105>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.32106>:
      }
      D.32107 = domain->runtime_info;
      D.32108 = MEM[(struct MonoJitDomainInfo *)D.32107].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.32108, method);
      D.32109 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.32109, method);
      D.32107 = domain->runtime_info;
      D.32110 = MEM[(struct MonoJitDomainInfo *)D.32107].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.32110, method);
      D.32107 = domain->runtime_info;
      D.32111 = MEM[(struct MonoJitDomainInfo *)D.32107].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.32111, method);
      D.32107 = domain->runtime_info;
      D.32112 = MEM[(struct MonoJitDomainInfo *)D.32107].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.32112);
      goto <D.26603>;
      <D.26602>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.171 = jlist;
        tmp = jlist.171->list;
        goto <D.26597>;
        <D.26596>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.32114 = ji->ji;
          D.32115 = D.32114->code_start;
          if (D.32115 <= ip) goto <D.32116>; else goto <D.32117>;
          <D.32116>:
          D.32114 = ji->ji;
          D.32115 = D.32114->code_start;
          D.32114 = ji->ji;
          D.32118 = D.32114->code_size;
          D.32119 = (sizetype) D.32118;
          D.32120 = D.32115 + D.32119;
          if (D.32120 > ip) goto <D.32121>; else goto <D.32122>;
          <D.32121>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.32122>:
          <D.32117>:
        }
        tmp = tmp->next;
        <D.26597>:
        if (tmp != 0B) goto <D.26596>; else goto <D.26598>;
        <D.26598>:
        tmp = remove;
        goto <D.26600>;
        <D.26599>:
        jlist.171 = jlist;
        D.32123 = tmp->data;
        jlist.171 = jlist;
        D.32124 = jlist.171->list;
        D.32125 = monoeg_g_slist_delete_link (D.32124, D.32123);
        jlist.171->list = D.32125;
        tmp = tmp->next;
        <D.26600>:
        if (tmp != 0B) goto <D.26599>; else goto <D.26601>;
        <D.26601>:
        monoeg_g_slist_free (remove);
      }
      <D.26603>:
      D.32126 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.32126 != 0) goto <D.26602>; else goto <D.26604>;
      <D.26604>:
      {
        int ret;

        D.32083 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.32083);
        if (ret != 0) goto <D.32127>; else goto <D.32128>;
        <D.32127>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.32128>:
        D.32129 = ret != 0;
        D.32130 = (long int) D.32129;
        D.32131 = __builtin_expect (D.32130, 0);
        if (D.32131 != 0) goto <D.32132>; else goto <D.32133>;
        <D.32132>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.32133>:
      }
      D.32134 = debug_options.keep_delegates;
      if (D.32134 != 0) goto <D.32135>; else goto <D.32136>;
      <D.32135>:
      D.32137 = BIT_FIELD_REF <*method, 8, 256>;
      D.32138 = D.32137 & 124;
      if (D.32138 == 20) goto <D.32139>; else goto <D.32140>;
      <D.32139>:
      {
        char * type;
        char * type_and_method;

        D.32141 = method->klass;
        D.32142 = &D.32141->byval_arg;
        type = mono_type_full_name (D.32142);
        D.32143 = method->name;
        type_and_method = monoeg_g_strdup_printf ("%s.%s", type, D.32143);
        monoeg_g_free (type);
        D.32114 = ji->ji;
        mono_arch_invalidate_method (D.32114, invalidated_delegate_trampoline, type_and_method);
        destroy = 0;
      }
      <D.32140>:
      <D.32136>:
      D.32114 = ji->ji;
      mono_jit_info_table_remove (domain, D.32114);
      if (destroy != 0) goto <D.32144>; else goto <D.32145>;
      <D.32144>:
      D.32146 = ji->code_mp;
      mono_code_manager_destroy (D.32146);
      <D.32145>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


invalidated_delegate_trampoline (char * desc)
{
  monoeg_g_log (0B, 4, "Unmanaged code called delegate of type %s which was already garbage collected.\nSee http://www.mono-project.com/Diagnostic:Delegate for an explanation and ways to fix this.", desc);
  <D.26581>:
  goto <D.26581>;
}


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.32152;
  struct MonoLMF * D.32155;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.32150>; else goto <D.32151>;
  <D.32150>:
  D.32152 = mono_thread_internal_current ();
  if (D.32152 == thread) goto <D.32153>; else goto <D.32154>;
  <D.32153>:
  mono_set_jit_tls (0B);
  <D.32154>:
  D.32155 = mono_get_lmf ();
  if (D.32155 != 0B) goto <D.32156>; else goto <D.32157>;
  <D.32156>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.32157>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.32151>:
}


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

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


mini_get_imt_trampoline (int slot_index)
{
  void * D.32159;
  int D.32160;

  D.32160 = slot_index + -19;
  D.32159 = mini_get_vtable_trampoline (D.32160);
  return D.32159;
}


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

  D.32162 = descr;
  return D.32162;
}


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

  D.32164 = addr;
  return D.32164;
}


mini_parse_debug_options ()
{
  int D.26773;
  int iftmp.172;
  int D.26772;
  const char[14] * D.32171;
  unsigned char D.32172;
  int D.32173;
  unsigned char D.32174;
  int D.32175;
  _Bool D.32176;
  _Bool D.32177;
  _Bool D.32178;
  const unsigned char * D.32181;
  unsigned char D.32182;
  int D.32183;
  const unsigned char * D.32184;
  unsigned char D.32185;
  int D.32186;
  _Bool D.32187;
  _Bool D.32188;
  const unsigned char * D.32191;
  unsigned char D.32192;
  int D.32193;
  const unsigned char * D.32194;
  unsigned char D.32195;
  int D.32196;
  _Bool D.32197;
  _Bool D.32198;
  const unsigned char * D.32201;
  unsigned char D.32202;
  int D.32203;
  const unsigned char * D.32204;
  unsigned char D.32205;
  int D.32206;
  int D.26782;
  int iftmp.173;
  int D.26781;
  const char[15] * D.32214;
  unsigned char D.32215;
  int D.32216;
  unsigned char D.32217;
  int D.32218;
  _Bool D.32219;
  _Bool D.32220;
  _Bool D.32221;
  const unsigned char * D.32224;
  unsigned char D.32225;
  int D.32226;
  const unsigned char * D.32227;
  unsigned char D.32228;
  int D.32229;
  _Bool D.32230;
  _Bool D.32231;
  const unsigned char * D.32234;
  unsigned char D.32235;
  int D.32236;
  const unsigned char * D.32237;
  unsigned char D.32238;
  int D.32239;
  _Bool D.32240;
  _Bool D.32241;
  const unsigned char * D.32244;
  unsigned char D.32245;
  int D.32246;
  const unsigned char * D.32247;
  unsigned char D.32248;
  int D.32249;
  int D.26791;
  int iftmp.174;
  int D.26790;
  const char[27] * D.32257;
  unsigned char D.32258;
  int D.32259;
  unsigned char D.32260;
  int D.32261;
  _Bool D.32262;
  _Bool D.32263;
  _Bool D.32264;
  const unsigned char * D.32267;
  unsigned char D.32268;
  int D.32269;
  const unsigned char * D.32270;
  unsigned char D.32271;
  int D.32272;
  _Bool D.32273;
  _Bool D.32274;
  const unsigned char * D.32277;
  unsigned char D.32278;
  int D.32279;
  const unsigned char * D.32280;
  unsigned char D.32281;
  int D.32282;
  _Bool D.32283;
  _Bool D.32284;
  const unsigned char * D.32287;
  unsigned char D.32288;
  int D.32289;
  const unsigned char * D.32290;
  unsigned char D.32291;
  int D.32292;
  int D.26800;
  int iftmp.175;
  int D.26799;
  const char[24] * D.32300;
  unsigned char D.32301;
  int D.32302;
  unsigned char D.32303;
  int D.32304;
  _Bool D.32305;
  _Bool D.32306;
  _Bool D.32307;
  const unsigned char * D.32310;
  unsigned char D.32311;
  int D.32312;
  const unsigned char * D.32313;
  unsigned char D.32314;
  int D.32315;
  _Bool D.32316;
  _Bool D.32317;
  const unsigned char * D.32320;
  unsigned char D.32321;
  int D.32322;
  const unsigned char * D.32323;
  unsigned char D.32324;
  int D.32325;
  _Bool D.32326;
  _Bool D.32327;
  const unsigned char * D.32330;
  unsigned char D.32331;
  int D.32332;
  const unsigned char * D.32333;
  unsigned char D.32334;
  int D.32335;
  int D.26809;
  int iftmp.176;
  int D.26808;
  const char[20] * D.32343;
  unsigned char D.32344;
  int D.32345;
  unsigned char D.32346;
  int D.32347;
  _Bool D.32348;
  _Bool D.32349;
  _Bool D.32350;
  const unsigned char * D.32353;
  unsigned char D.32354;
  int D.32355;
  const unsigned char * D.32356;
  unsigned char D.32357;
  int D.32358;
  _Bool D.32359;
  _Bool D.32360;
  const unsigned char * D.32363;
  unsigned char D.32364;
  int D.32365;
  const unsigned char * D.32366;
  unsigned char D.32367;
  int D.32368;
  _Bool D.32369;
  _Bool D.32370;
  const unsigned char * D.32373;
  unsigned char D.32374;
  int D.32375;
  const unsigned char * D.32376;
  unsigned char D.32377;
  int D.32378;
  int D.26818;
  int iftmp.177;
  int D.26817;
  const char[17] * D.32386;
  unsigned char D.32387;
  int D.32388;
  unsigned char D.32389;
  int D.32390;
  _Bool D.32391;
  _Bool D.32392;
  _Bool D.32393;
  const unsigned char * D.32396;
  unsigned char D.32397;
  int D.32398;
  const unsigned char * D.32399;
  unsigned char D.32400;
  int D.32401;
  _Bool D.32402;
  _Bool D.32403;
  const unsigned char * D.32406;
  unsigned char D.32407;
  int D.32408;
  const unsigned char * D.32409;
  unsigned char D.32410;
  int D.32411;
  _Bool D.32412;
  _Bool D.32413;
  const unsigned char * D.32416;
  unsigned char D.32417;
  int D.32418;
  const unsigned char * D.32419;
  unsigned char D.32420;
  int D.32421;
  int D.26827;
  int iftmp.178;
  int D.26826;
  const char[19] * D.32429;
  unsigned char D.32430;
  int D.32431;
  unsigned char D.32432;
  int D.32433;
  _Bool D.32434;
  _Bool D.32435;
  _Bool D.32436;
  const unsigned char * D.32439;
  unsigned char D.32440;
  int D.32441;
  const unsigned char * D.32442;
  unsigned char D.32443;
  int D.32444;
  _Bool D.32445;
  _Bool D.32446;
  const unsigned char * D.32449;
  unsigned char D.32450;
  int D.32451;
  const unsigned char * D.32452;
  unsigned char D.32453;
  int D.32454;
  _Bool D.32455;
  _Bool D.32456;
  const unsigned char * D.32459;
  unsigned char D.32460;
  int D.32461;
  const unsigned char * D.32462;
  unsigned char D.32463;
  int D.32464;
  int D.26836;
  int iftmp.179;
  int D.26835;
  const char[21] * D.32472;
  unsigned char D.32473;
  int D.32474;
  unsigned char D.32475;
  int D.32476;
  _Bool D.32477;
  _Bool D.32478;
  _Bool D.32479;
  const unsigned char * D.32482;
  unsigned char D.32483;
  int D.32484;
  const unsigned char * D.32485;
  unsigned char D.32486;
  int D.32487;
  _Bool D.32488;
  _Bool D.32489;
  const unsigned char * D.32492;
  unsigned char D.32493;
  int D.32494;
  const unsigned char * D.32495;
  unsigned char D.32496;
  int D.32497;
  _Bool D.32498;
  _Bool D.32499;
  const unsigned char * D.32502;
  unsigned char D.32503;
  int D.32504;
  const unsigned char * D.32505;
  unsigned char D.32506;
  int D.32507;
  int D.26845;
  int iftmp.180;
  int D.26844;
  const char[18] * D.32515;
  unsigned char D.32516;
  int D.32517;
  unsigned char D.32518;
  int D.32519;
  _Bool D.32520;
  _Bool D.32521;
  _Bool D.32522;
  const unsigned char * D.32525;
  unsigned char D.32526;
  int D.32527;
  const unsigned char * D.32528;
  unsigned char D.32529;
  int D.32530;
  _Bool D.32531;
  _Bool D.32532;
  const unsigned char * D.32535;
  unsigned char D.32536;
  int D.32537;
  const unsigned char * D.32538;
  unsigned char D.32539;
  int D.32540;
  _Bool D.32541;
  _Bool D.32542;
  const unsigned char * D.32545;
  unsigned char D.32546;
  int D.32547;
  const unsigned char * D.32548;
  unsigned char D.32549;
  int D.32550;
  int D.26854;
  int iftmp.181;
  int D.26853;
  const char[19] * D.32558;
  unsigned char D.32559;
  int D.32560;
  unsigned char D.32561;
  int D.32562;
  _Bool D.32563;
  _Bool D.32564;
  _Bool D.32565;
  const unsigned char * D.32568;
  unsigned char D.32569;
  int D.32570;
  const unsigned char * D.32571;
  unsigned char D.32572;
  int D.32573;
  _Bool D.32574;
  _Bool D.32575;
  const unsigned char * D.32578;
  unsigned char D.32579;
  int D.32580;
  const unsigned char * D.32581;
  unsigned char D.32582;
  int D.32583;
  _Bool D.32584;
  _Bool D.32585;
  const unsigned char * D.32588;
  unsigned char D.32589;
  int D.32590;
  const unsigned char * D.32591;
  unsigned char D.32592;
  int D.32593;
  int D.26863;
  int iftmp.182;
  int D.26862;
  const char[4] * D.32601;
  unsigned char D.32602;
  int D.32603;
  unsigned char D.32604;
  int D.32605;
  _Bool D.32606;
  _Bool D.32607;
  _Bool D.32608;
  const unsigned char * D.32611;
  unsigned char D.32612;
  int D.32613;
  const unsigned char * D.32614;
  unsigned char D.32615;
  int D.32616;
  _Bool D.32617;
  _Bool D.32618;
  const unsigned char * D.32621;
  unsigned char D.32622;
  int D.32623;
  const unsigned char * D.32624;
  unsigned char D.32625;
  int D.32626;
  _Bool D.32627;
  _Bool D.32628;
  const unsigned char * D.32631;
  unsigned char D.32632;
  int D.32633;
  const unsigned char * D.32634;
  unsigned char D.32635;
  int D.32636;
  int D.26872;
  int iftmp.183;
  int D.26871;
  const char[21] * D.32644;
  unsigned char D.32645;
  int D.32646;
  unsigned char D.32647;
  int D.32648;
  _Bool D.32649;
  _Bool D.32650;
  _Bool D.32651;
  const unsigned char * D.32654;
  unsigned char D.32655;
  int D.32656;
  const unsigned char * D.32657;
  unsigned char D.32658;
  int D.32659;
  _Bool D.32660;
  _Bool D.32661;
  const unsigned char * D.32664;
  unsigned char D.32665;
  int D.32666;
  const unsigned char * D.32667;
  unsigned char D.32668;
  int D.32669;
  _Bool D.32670;
  _Bool D.32671;
  const unsigned char * D.32674;
  unsigned char D.32675;
  int D.32676;
  const unsigned char * D.32677;
  unsigned char D.32678;
  int D.32679;
  int D.26881;
  int iftmp.184;
  int D.26880;
  const char[15] * D.32687;
  unsigned char D.32688;
  int D.32689;
  unsigned char D.32690;
  int D.32691;
  _Bool D.32692;
  _Bool D.32693;
  _Bool D.32694;
  const unsigned char * D.32697;
  unsigned char D.32698;
  int D.32699;
  const unsigned char * D.32700;
  unsigned char D.32701;
  int D.32702;
  _Bool D.32703;
  _Bool D.32704;
  const unsigned char * D.32707;
  unsigned char D.32708;
  int D.32709;
  const unsigned char * D.32710;
  unsigned char D.32711;
  int D.32712;
  _Bool D.32713;
  _Bool D.32714;
  const unsigned char * D.32717;
  unsigned char D.32718;
  int D.32719;
  const unsigned char * D.32720;
  unsigned char D.32721;
  int D.32722;
  int D.26890;
  int iftmp.185;
  int D.26889;
  const char[12] * D.32730;
  unsigned char D.32731;
  int D.32732;
  unsigned char D.32733;
  int D.32734;
  _Bool D.32735;
  _Bool D.32736;
  _Bool D.32737;
  const unsigned char * D.32740;
  unsigned char D.32741;
  int D.32742;
  const unsigned char * D.32743;
  unsigned char D.32744;
  int D.32745;
  _Bool D.32746;
  _Bool D.32747;
  const unsigned char * D.32750;
  unsigned char D.32751;
  int D.32752;
  const unsigned char * D.32753;
  unsigned char D.32754;
  int D.32755;
  _Bool D.32756;
  _Bool D.32757;
  const unsigned char * D.32760;
  unsigned char D.32761;
  int D.32762;
  const unsigned char * D.32763;
  unsigned char D.32764;
  int D.32765;
  int D.26899;
  int iftmp.186;
  int D.26898;
  const char[6] * D.32773;
  unsigned char D.32774;
  int D.32775;
  unsigned char D.32776;
  int D.32777;
  _Bool D.32778;
  _Bool D.32779;
  _Bool D.32780;
  const unsigned char * D.32783;
  unsigned char D.32784;
  int D.32785;
  const unsigned char * D.32786;
  unsigned char D.32787;
  int D.32788;
  _Bool D.32789;
  _Bool D.32790;
  const unsigned char * D.32793;
  unsigned char D.32794;
  int D.32795;
  const unsigned char * D.32796;
  unsigned char D.32797;
  int D.32798;
  _Bool D.32799;
  _Bool D.32800;
  const unsigned char * D.32803;
  unsigned char D.32804;
  int D.32805;
  const unsigned char * D.32806;
  unsigned char D.32807;
  int D.32808;
  int D.26908;
  int iftmp.187;
  int D.26907;
  const char[17] * D.32816;
  unsigned char D.32817;
  int D.32818;
  unsigned char D.32819;
  int D.32820;
  _Bool D.32821;
  _Bool D.32822;
  _Bool D.32823;
  const unsigned char * D.32826;
  unsigned char D.32827;
  int D.32828;
  const unsigned char * D.32829;
  unsigned char D.32830;
  int D.32831;
  _Bool D.32832;
  _Bool D.32833;
  const unsigned char * D.32836;
  unsigned char D.32837;
  int D.32838;
  const unsigned char * D.32839;
  unsigned char D.32840;
  int D.32841;
  _Bool D.32842;
  _Bool D.32843;
  const unsigned char * D.32846;
  unsigned char D.32847;
  int D.32848;
  const unsigned char * D.32849;
  unsigned char D.32850;
  int D.32851;
  struct _IO_FILE * stderr.188;
  gchar * D.32858;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.32166>; else goto <D.32167>;
  <D.32166>:
  return;
  <D.32167>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.26910>;
  <D.26909>:
  {
    const char * arg;

    arg = *ptr;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 13;
      if (__s2_len <= 3) goto <D.32169>; else goto <D.32170>;
      <D.32169>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32171 = "handle-sigint";
        D.32172 = MEM[(const unsigned char *)D.32171];
        D.32173 = (int) D.32172;
        D.32174 = *__s2;
        D.32175 = (int) D.32174;
        __result = D.32173 - D.32175;
        {
          D.32176 = __s2_len != 0;
          D.32177 = __result == 0;
          D.32178 = D.32176 & D.32177;
          if (D.32178 != 0) goto <D.32179>; else goto <D.32180>;
          <D.32179>:
          D.32181 = &MEM[(void *)"handle-sigint" + 1B];
          D.32182 = *D.32181;
          D.32183 = (int) D.32182;
          D.32184 = __s2 + 1;
          D.32185 = *D.32184;
          D.32186 = (int) D.32185;
          __result = D.32183 - D.32186;
          D.32187 = __s2_len > 1;
          D.32177 = __result == 0;
          D.32188 = D.32187 & D.32177;
          if (D.32188 != 0) goto <D.32189>; else goto <D.32190>;
          <D.32189>:
          D.32191 = &MEM[(void *)"handle-sigint" + 2B];
          D.32192 = *D.32191;
          D.32193 = (int) D.32192;
          D.32194 = __s2 + 2;
          D.32195 = *D.32194;
          D.32196 = (int) D.32195;
          __result = D.32193 - D.32196;
          D.32197 = __s2_len > 2;
          D.32177 = __result == 0;
          D.32198 = D.32197 & D.32177;
          if (D.32198 != 0) goto <D.32199>; else goto <D.32200>;
          <D.32199>:
          D.32201 = &MEM[(void *)"handle-sigint" + 3B];
          D.32202 = *D.32201;
          D.32203 = (int) D.32202;
          D.32204 = __s2 + 3;
          D.32205 = *D.32204;
          D.32206 = (int) D.32205;
          __result = D.32203 - D.32206;
          <D.32200>:
          <D.32190>:
          <D.32180>:
        }
        D.26772 = __result;
      }
      iftmp.172 = -D.26772;
      goto <D.32207>;
      <D.32170>:
      iftmp.172 = __builtin_strcmp (arg, "handle-sigint");
      <D.32207>:
      D.26773 = iftmp.172;
    }
    if (D.26773 == 0) goto <D.32208>; else goto <D.32209>;
    <D.32208>:
    debug_options.handle_sigint = 1;
    goto <D.32210>;
    <D.32209>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 14;
      if (__s2_len <= 3) goto <D.32212>; else goto <D.32213>;
      <D.32212>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32214 = "keep-delegates";
        D.32215 = MEM[(const unsigned char *)D.32214];
        D.32216 = (int) D.32215;
        D.32217 = *__s2;
        D.32218 = (int) D.32217;
        __result = D.32216 - D.32218;
        {
          D.32219 = __s2_len != 0;
          D.32220 = __result == 0;
          D.32221 = D.32219 & D.32220;
          if (D.32221 != 0) goto <D.32222>; else goto <D.32223>;
          <D.32222>:
          D.32224 = &MEM[(void *)"keep-delegates" + 1B];
          D.32225 = *D.32224;
          D.32226 = (int) D.32225;
          D.32227 = __s2 + 1;
          D.32228 = *D.32227;
          D.32229 = (int) D.32228;
          __result = D.32226 - D.32229;
          D.32230 = __s2_len > 1;
          D.32220 = __result == 0;
          D.32231 = D.32230 & D.32220;
          if (D.32231 != 0) goto <D.32232>; else goto <D.32233>;
          <D.32232>:
          D.32234 = &MEM[(void *)"keep-delegates" + 2B];
          D.32235 = *D.32234;
          D.32236 = (int) D.32235;
          D.32237 = __s2 + 2;
          D.32238 = *D.32237;
          D.32239 = (int) D.32238;
          __result = D.32236 - D.32239;
          D.32240 = __s2_len > 2;
          D.32220 = __result == 0;
          D.32241 = D.32240 & D.32220;
          if (D.32241 != 0) goto <D.32242>; else goto <D.32243>;
          <D.32242>:
          D.32244 = &MEM[(void *)"keep-delegates" + 3B];
          D.32245 = *D.32244;
          D.32246 = (int) D.32245;
          D.32247 = __s2 + 3;
          D.32248 = *D.32247;
          D.32249 = (int) D.32248;
          __result = D.32246 - D.32249;
          <D.32243>:
          <D.32233>:
          <D.32223>:
        }
        D.26781 = __result;
      }
      iftmp.173 = -D.26781;
      goto <D.32250>;
      <D.32213>:
      iftmp.173 = __builtin_strcmp (arg, "keep-delegates");
      <D.32250>:
      D.26782 = iftmp.173;
    }
    if (D.26782 == 0) goto <D.32251>; else goto <D.32252>;
    <D.32251>:
    debug_options.keep_delegates = 1;
    goto <D.32253>;
    <D.32252>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 26;
      if (__s2_len <= 3) goto <D.32255>; else goto <D.32256>;
      <D.32255>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32257 = "reverse-pinvoke-exceptions";
        D.32258 = MEM[(const unsigned char *)D.32257];
        D.32259 = (int) D.32258;
        D.32260 = *__s2;
        D.32261 = (int) D.32260;
        __result = D.32259 - D.32261;
        {
          D.32262 = __s2_len != 0;
          D.32263 = __result == 0;
          D.32264 = D.32262 & D.32263;
          if (D.32264 != 0) goto <D.32265>; else goto <D.32266>;
          <D.32265>:
          D.32267 = &MEM[(void *)"reverse-pinvoke-exceptions" + 1B];
          D.32268 = *D.32267;
          D.32269 = (int) D.32268;
          D.32270 = __s2 + 1;
          D.32271 = *D.32270;
          D.32272 = (int) D.32271;
          __result = D.32269 - D.32272;
          D.32273 = __s2_len > 1;
          D.32263 = __result == 0;
          D.32274 = D.32273 & D.32263;
          if (D.32274 != 0) goto <D.32275>; else goto <D.32276>;
          <D.32275>:
          D.32277 = &MEM[(void *)"reverse-pinvoke-exceptions" + 2B];
          D.32278 = *D.32277;
          D.32279 = (int) D.32278;
          D.32280 = __s2 + 2;
          D.32281 = *D.32280;
          D.32282 = (int) D.32281;
          __result = D.32279 - D.32282;
          D.32283 = __s2_len > 2;
          D.32263 = __result == 0;
          D.32284 = D.32283 & D.32263;
          if (D.32284 != 0) goto <D.32285>; else goto <D.32286>;
          <D.32285>:
          D.32287 = &MEM[(void *)"reverse-pinvoke-exceptions" + 3B];
          D.32288 = *D.32287;
          D.32289 = (int) D.32288;
          D.32290 = __s2 + 3;
          D.32291 = *D.32290;
          D.32292 = (int) D.32291;
          __result = D.32289 - D.32292;
          <D.32286>:
          <D.32276>:
          <D.32266>:
        }
        D.26790 = __result;
      }
      iftmp.174 = -D.26790;
      goto <D.32293>;
      <D.32256>:
      iftmp.174 = __builtin_strcmp (arg, "reverse-pinvoke-exceptions");
      <D.32293>:
      D.26791 = iftmp.174;
    }
    if (D.26791 == 0) goto <D.32294>; else goto <D.32295>;
    <D.32294>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.32296>;
    <D.32295>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 23;
      if (__s2_len <= 3) goto <D.32298>; else goto <D.32299>;
      <D.32298>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32300 = "collect-pagefault-stats";
        D.32301 = MEM[(const unsigned char *)D.32300];
        D.32302 = (int) D.32301;
        D.32303 = *__s2;
        D.32304 = (int) D.32303;
        __result = D.32302 - D.32304;
        {
          D.32305 = __s2_len != 0;
          D.32306 = __result == 0;
          D.32307 = D.32305 & D.32306;
          if (D.32307 != 0) goto <D.32308>; else goto <D.32309>;
          <D.32308>:
          D.32310 = &MEM[(void *)"collect-pagefault-stats" + 1B];
          D.32311 = *D.32310;
          D.32312 = (int) D.32311;
          D.32313 = __s2 + 1;
          D.32314 = *D.32313;
          D.32315 = (int) D.32314;
          __result = D.32312 - D.32315;
          D.32316 = __s2_len > 1;
          D.32306 = __result == 0;
          D.32317 = D.32316 & D.32306;
          if (D.32317 != 0) goto <D.32318>; else goto <D.32319>;
          <D.32318>:
          D.32320 = &MEM[(void *)"collect-pagefault-stats" + 2B];
          D.32321 = *D.32320;
          D.32322 = (int) D.32321;
          D.32323 = __s2 + 2;
          D.32324 = *D.32323;
          D.32325 = (int) D.32324;
          __result = D.32322 - D.32325;
          D.32326 = __s2_len > 2;
          D.32306 = __result == 0;
          D.32327 = D.32326 & D.32306;
          if (D.32327 != 0) goto <D.32328>; else goto <D.32329>;
          <D.32328>:
          D.32330 = &MEM[(void *)"collect-pagefault-stats" + 3B];
          D.32331 = *D.32330;
          D.32332 = (int) D.32331;
          D.32333 = __s2 + 3;
          D.32334 = *D.32333;
          D.32335 = (int) D.32334;
          __result = D.32332 - D.32335;
          <D.32329>:
          <D.32319>:
          <D.32309>:
        }
        D.26799 = __result;
      }
      iftmp.175 = -D.26799;
      goto <D.32336>;
      <D.32299>:
      iftmp.175 = __builtin_strcmp (arg, "collect-pagefault-stats");
      <D.32336>:
      D.26800 = iftmp.175;
    }
    if (D.26800 == 0) goto <D.32337>; else goto <D.32338>;
    <D.32337>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.32339>;
    <D.32338>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 19;
      if (__s2_len <= 3) goto <D.32341>; else goto <D.32342>;
      <D.32341>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32343 = "break-on-unverified";
        D.32344 = MEM[(const unsigned char *)D.32343];
        D.32345 = (int) D.32344;
        D.32346 = *__s2;
        D.32347 = (int) D.32346;
        __result = D.32345 - D.32347;
        {
          D.32348 = __s2_len != 0;
          D.32349 = __result == 0;
          D.32350 = D.32348 & D.32349;
          if (D.32350 != 0) goto <D.32351>; else goto <D.32352>;
          <D.32351>:
          D.32353 = &MEM[(void *)"break-on-unverified" + 1B];
          D.32354 = *D.32353;
          D.32355 = (int) D.32354;
          D.32356 = __s2 + 1;
          D.32357 = *D.32356;
          D.32358 = (int) D.32357;
          __result = D.32355 - D.32358;
          D.32359 = __s2_len > 1;
          D.32349 = __result == 0;
          D.32360 = D.32359 & D.32349;
          if (D.32360 != 0) goto <D.32361>; else goto <D.32362>;
          <D.32361>:
          D.32363 = &MEM[(void *)"break-on-unverified" + 2B];
          D.32364 = *D.32363;
          D.32365 = (int) D.32364;
          D.32366 = __s2 + 2;
          D.32367 = *D.32366;
          D.32368 = (int) D.32367;
          __result = D.32365 - D.32368;
          D.32369 = __s2_len > 2;
          D.32349 = __result == 0;
          D.32370 = D.32369 & D.32349;
          if (D.32370 != 0) goto <D.32371>; else goto <D.32372>;
          <D.32371>:
          D.32373 = &MEM[(void *)"break-on-unverified" + 3B];
          D.32374 = *D.32373;
          D.32375 = (int) D.32374;
          D.32376 = __s2 + 3;
          D.32377 = *D.32376;
          D.32378 = (int) D.32377;
          __result = D.32375 - D.32378;
          <D.32372>:
          <D.32362>:
          <D.32352>:
        }
        D.26808 = __result;
      }
      iftmp.176 = -D.26808;
      goto <D.32379>;
      <D.32342>:
      iftmp.176 = __builtin_strcmp (arg, "break-on-unverified");
      <D.32379>:
      D.26809 = iftmp.176;
    }
    if (D.26809 == 0) goto <D.32380>; else goto <D.32381>;
    <D.32380>:
    debug_options.break_on_unverified = 1;
    goto <D.32382>;
    <D.32381>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 16;
      if (__s2_len <= 3) goto <D.32384>; else goto <D.32385>;
      <D.32384>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32386 = "no-gdb-backtrace";
        D.32387 = MEM[(const unsigned char *)D.32386];
        D.32388 = (int) D.32387;
        D.32389 = *__s2;
        D.32390 = (int) D.32389;
        __result = D.32388 - D.32390;
        {
          D.32391 = __s2_len != 0;
          D.32392 = __result == 0;
          D.32393 = D.32391 & D.32392;
          if (D.32393 != 0) goto <D.32394>; else goto <D.32395>;
          <D.32394>:
          D.32396 = &MEM[(void *)"no-gdb-backtrace" + 1B];
          D.32397 = *D.32396;
          D.32398 = (int) D.32397;
          D.32399 = __s2 + 1;
          D.32400 = *D.32399;
          D.32401 = (int) D.32400;
          __result = D.32398 - D.32401;
          D.32402 = __s2_len > 1;
          D.32392 = __result == 0;
          D.32403 = D.32402 & D.32392;
          if (D.32403 != 0) goto <D.32404>; else goto <D.32405>;
          <D.32404>:
          D.32406 = &MEM[(void *)"no-gdb-backtrace" + 2B];
          D.32407 = *D.32406;
          D.32408 = (int) D.32407;
          D.32409 = __s2 + 2;
          D.32410 = *D.32409;
          D.32411 = (int) D.32410;
          __result = D.32408 - D.32411;
          D.32412 = __s2_len > 2;
          D.32392 = __result == 0;
          D.32413 = D.32412 & D.32392;
          if (D.32413 != 0) goto <D.32414>; else goto <D.32415>;
          <D.32414>:
          D.32416 = &MEM[(void *)"no-gdb-backtrace" + 3B];
          D.32417 = *D.32416;
          D.32418 = (int) D.32417;
          D.32419 = __s2 + 3;
          D.32420 = *D.32419;
          D.32421 = (int) D.32420;
          __result = D.32418 - D.32421;
          <D.32415>:
          <D.32405>:
          <D.32395>:
        }
        D.26817 = __result;
      }
      iftmp.177 = -D.26817;
      goto <D.32422>;
      <D.32385>:
      iftmp.177 = __builtin_strcmp (arg, "no-gdb-backtrace");
      <D.32422>:
      D.26818 = iftmp.177;
    }
    if (D.26818 == 0) goto <D.32423>; else goto <D.32424>;
    <D.32423>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.32425>;
    <D.32424>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 18;
      if (__s2_len <= 3) goto <D.32427>; else goto <D.32428>;
      <D.32427>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32429 = "suspend-on-sigsegv";
        D.32430 = MEM[(const unsigned char *)D.32429];
        D.32431 = (int) D.32430;
        D.32432 = *__s2;
        D.32433 = (int) D.32432;
        __result = D.32431 - D.32433;
        {
          D.32434 = __s2_len != 0;
          D.32435 = __result == 0;
          D.32436 = D.32434 & D.32435;
          if (D.32436 != 0) goto <D.32437>; else goto <D.32438>;
          <D.32437>:
          D.32439 = &MEM[(void *)"suspend-on-sigsegv" + 1B];
          D.32440 = *D.32439;
          D.32441 = (int) D.32440;
          D.32442 = __s2 + 1;
          D.32443 = *D.32442;
          D.32444 = (int) D.32443;
          __result = D.32441 - D.32444;
          D.32445 = __s2_len > 1;
          D.32435 = __result == 0;
          D.32446 = D.32445 & D.32435;
          if (D.32446 != 0) goto <D.32447>; else goto <D.32448>;
          <D.32447>:
          D.32449 = &MEM[(void *)"suspend-on-sigsegv" + 2B];
          D.32450 = *D.32449;
          D.32451 = (int) D.32450;
          D.32452 = __s2 + 2;
          D.32453 = *D.32452;
          D.32454 = (int) D.32453;
          __result = D.32451 - D.32454;
          D.32455 = __s2_len > 2;
          D.32435 = __result == 0;
          D.32456 = D.32455 & D.32435;
          if (D.32456 != 0) goto <D.32457>; else goto <D.32458>;
          <D.32457>:
          D.32459 = &MEM[(void *)"suspend-on-sigsegv" + 3B];
          D.32460 = *D.32459;
          D.32461 = (int) D.32460;
          D.32462 = __s2 + 3;
          D.32463 = *D.32462;
          D.32464 = (int) D.32463;
          __result = D.32461 - D.32464;
          <D.32458>:
          <D.32448>:
          <D.32438>:
        }
        D.26826 = __result;
      }
      iftmp.178 = -D.26826;
      goto <D.32465>;
      <D.32428>:
      iftmp.178 = __builtin_strcmp (arg, "suspend-on-sigsegv");
      <D.32465>:
      D.26827 = iftmp.178;
    }
    if (D.26827 == 0) goto <D.32466>; else goto <D.32467>;
    <D.32466>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.32468>;
    <D.32467>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 20;
      if (__s2_len <= 3) goto <D.32470>; else goto <D.32471>;
      <D.32470>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32472 = "suspend-on-unhandled";
        D.32473 = MEM[(const unsigned char *)D.32472];
        D.32474 = (int) D.32473;
        D.32475 = *__s2;
        D.32476 = (int) D.32475;
        __result = D.32474 - D.32476;
        {
          D.32477 = __s2_len != 0;
          D.32478 = __result == 0;
          D.32479 = D.32477 & D.32478;
          if (D.32479 != 0) goto <D.32480>; else goto <D.32481>;
          <D.32480>:
          D.32482 = &MEM[(void *)"suspend-on-unhandled" + 1B];
          D.32483 = *D.32482;
          D.32484 = (int) D.32483;
          D.32485 = __s2 + 1;
          D.32486 = *D.32485;
          D.32487 = (int) D.32486;
          __result = D.32484 - D.32487;
          D.32488 = __s2_len > 1;
          D.32478 = __result == 0;
          D.32489 = D.32488 & D.32478;
          if (D.32489 != 0) goto <D.32490>; else goto <D.32491>;
          <D.32490>:
          D.32492 = &MEM[(void *)"suspend-on-unhandled" + 2B];
          D.32493 = *D.32492;
          D.32494 = (int) D.32493;
          D.32495 = __s2 + 2;
          D.32496 = *D.32495;
          D.32497 = (int) D.32496;
          __result = D.32494 - D.32497;
          D.32498 = __s2_len > 2;
          D.32478 = __result == 0;
          D.32499 = D.32498 & D.32478;
          if (D.32499 != 0) goto <D.32500>; else goto <D.32501>;
          <D.32500>:
          D.32502 = &MEM[(void *)"suspend-on-unhandled" + 3B];
          D.32503 = *D.32502;
          D.32504 = (int) D.32503;
          D.32505 = __s2 + 3;
          D.32506 = *D.32505;
          D.32507 = (int) D.32506;
          __result = D.32504 - D.32507;
          <D.32501>:
          <D.32491>:
          <D.32481>:
        }
        D.26835 = __result;
      }
      iftmp.179 = -D.26835;
      goto <D.32508>;
      <D.32471>:
      iftmp.179 = __builtin_strcmp (arg, "suspend-on-unhandled");
      <D.32508>:
      D.26836 = iftmp.179;
    }
    if (D.26836 == 0) goto <D.32509>; else goto <D.32510>;
    <D.32509>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.32511>;
    <D.32510>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 17;
      if (__s2_len <= 3) goto <D.32513>; else goto <D.32514>;
      <D.32513>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32515 = "dont-free-domains";
        D.32516 = MEM[(const unsigned char *)D.32515];
        D.32517 = (int) D.32516;
        D.32518 = *__s2;
        D.32519 = (int) D.32518;
        __result = D.32517 - D.32519;
        {
          D.32520 = __s2_len != 0;
          D.32521 = __result == 0;
          D.32522 = D.32520 & D.32521;
          if (D.32522 != 0) goto <D.32523>; else goto <D.32524>;
          <D.32523>:
          D.32525 = &MEM[(void *)"dont-free-domains" + 1B];
          D.32526 = *D.32525;
          D.32527 = (int) D.32526;
          D.32528 = __s2 + 1;
          D.32529 = *D.32528;
          D.32530 = (int) D.32529;
          __result = D.32527 - D.32530;
          D.32531 = __s2_len > 1;
          D.32521 = __result == 0;
          D.32532 = D.32531 & D.32521;
          if (D.32532 != 0) goto <D.32533>; else goto <D.32534>;
          <D.32533>:
          D.32535 = &MEM[(void *)"dont-free-domains" + 2B];
          D.32536 = *D.32535;
          D.32537 = (int) D.32536;
          D.32538 = __s2 + 2;
          D.32539 = *D.32538;
          D.32540 = (int) D.32539;
          __result = D.32537 - D.32540;
          D.32541 = __s2_len > 2;
          D.32521 = __result == 0;
          D.32542 = D.32541 & D.32521;
          if (D.32542 != 0) goto <D.32543>; else goto <D.32544>;
          <D.32543>:
          D.32545 = &MEM[(void *)"dont-free-domains" + 3B];
          D.32546 = *D.32545;
          D.32547 = (int) D.32546;
          D.32548 = __s2 + 3;
          D.32549 = *D.32548;
          D.32550 = (int) D.32549;
          __result = D.32547 - D.32550;
          <D.32544>:
          <D.32534>:
          <D.32524>:
        }
        D.26844 = __result;
      }
      iftmp.180 = -D.26844;
      goto <D.32551>;
      <D.32514>:
      iftmp.180 = __builtin_strcmp (arg, "dont-free-domains");
      <D.32551>:
      D.26845 = iftmp.180;
    }
    if (D.26845 == 0) goto <D.32552>; else goto <D.32553>;
    <D.32552>:
    mono_dont_free_domains = 1;
    goto <D.32554>;
    <D.32553>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 18;
      if (__s2_len <= 3) goto <D.32556>; else goto <D.32557>;
      <D.32556>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32558 = "dyn-runtime-invoke";
        D.32559 = MEM[(const unsigned char *)D.32558];
        D.32560 = (int) D.32559;
        D.32561 = *__s2;
        D.32562 = (int) D.32561;
        __result = D.32560 - D.32562;
        {
          D.32563 = __s2_len != 0;
          D.32564 = __result == 0;
          D.32565 = D.32563 & D.32564;
          if (D.32565 != 0) goto <D.32566>; else goto <D.32567>;
          <D.32566>:
          D.32568 = &MEM[(void *)"dyn-runtime-invoke" + 1B];
          D.32569 = *D.32568;
          D.32570 = (int) D.32569;
          D.32571 = __s2 + 1;
          D.32572 = *D.32571;
          D.32573 = (int) D.32572;
          __result = D.32570 - D.32573;
          D.32574 = __s2_len > 1;
          D.32564 = __result == 0;
          D.32575 = D.32574 & D.32564;
          if (D.32575 != 0) goto <D.32576>; else goto <D.32577>;
          <D.32576>:
          D.32578 = &MEM[(void *)"dyn-runtime-invoke" + 2B];
          D.32579 = *D.32578;
          D.32580 = (int) D.32579;
          D.32581 = __s2 + 2;
          D.32582 = *D.32581;
          D.32583 = (int) D.32582;
          __result = D.32580 - D.32583;
          D.32584 = __s2_len > 2;
          D.32564 = __result == 0;
          D.32585 = D.32584 & D.32564;
          if (D.32585 != 0) goto <D.32586>; else goto <D.32587>;
          <D.32586>:
          D.32588 = &MEM[(void *)"dyn-runtime-invoke" + 3B];
          D.32589 = *D.32588;
          D.32590 = (int) D.32589;
          D.32591 = __s2 + 3;
          D.32592 = *D.32591;
          D.32593 = (int) D.32592;
          __result = D.32590 - D.32593;
          <D.32587>:
          <D.32577>:
          <D.32567>:
        }
        D.26853 = __result;
      }
      iftmp.181 = -D.26853;
      goto <D.32594>;
      <D.32557>:
      iftmp.181 = __builtin_strcmp (arg, "dyn-runtime-invoke");
      <D.32594>:
      D.26854 = iftmp.181;
    }
    if (D.26854 == 0) goto <D.32595>; else goto <D.32596>;
    <D.32595>:
    debug_options.dyn_runtime_invoke = 1;
    goto <D.32597>;
    <D.32596>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 3;
      if (__s2_len <= 3) goto <D.32599>; else goto <D.32600>;
      <D.32599>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32601 = "gdb";
        D.32602 = MEM[(const unsigned char *)D.32601];
        D.32603 = (int) D.32602;
        D.32604 = *__s2;
        D.32605 = (int) D.32604;
        __result = D.32603 - D.32605;
        {
          D.32606 = __s2_len != 0;
          D.32607 = __result == 0;
          D.32608 = D.32606 & D.32607;
          if (D.32608 != 0) goto <D.32609>; else goto <D.32610>;
          <D.32609>:
          D.32611 = &MEM[(void *)"gdb" + 1B];
          D.32612 = *D.32611;
          D.32613 = (int) D.32612;
          D.32614 = __s2 + 1;
          D.32615 = *D.32614;
          D.32616 = (int) D.32615;
          __result = D.32613 - D.32616;
          D.32617 = __s2_len > 1;
          D.32607 = __result == 0;
          D.32618 = D.32617 & D.32607;
          if (D.32618 != 0) goto <D.32619>; else goto <D.32620>;
          <D.32619>:
          D.32621 = &MEM[(void *)"gdb" + 2B];
          D.32622 = *D.32621;
          D.32623 = (int) D.32622;
          D.32624 = __s2 + 2;
          D.32625 = *D.32624;
          D.32626 = (int) D.32625;
          __result = D.32623 - D.32626;
          D.32627 = __s2_len > 2;
          D.32607 = __result == 0;
          D.32628 = D.32627 & D.32607;
          if (D.32628 != 0) goto <D.32629>; else goto <D.32630>;
          <D.32629>:
          D.32631 = &MEM[(void *)"gdb" + 3B];
          D.32632 = *D.32631;
          D.32633 = (int) D.32632;
          D.32634 = __s2 + 3;
          D.32635 = *D.32634;
          D.32636 = (int) D.32635;
          __result = D.32633 - D.32636;
          <D.32630>:
          <D.32620>:
          <D.32610>:
        }
        D.26862 = __result;
      }
      iftmp.182 = -D.26862;
      goto <D.32637>;
      <D.32600>:
      iftmp.182 = __builtin_strcmp (arg, "gdb");
      <D.32637>:
      D.26863 = iftmp.182;
    }
    if (D.26863 == 0) goto <D.32638>; else goto <D.32639>;
    <D.32638>:
    debug_options.gdb = 1;
    goto <D.32640>;
    <D.32639>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 20;
      if (__s2_len <= 3) goto <D.32642>; else goto <D.32643>;
      <D.32642>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32644 = "explicit-null-checks";
        D.32645 = MEM[(const unsigned char *)D.32644];
        D.32646 = (int) D.32645;
        D.32647 = *__s2;
        D.32648 = (int) D.32647;
        __result = D.32646 - D.32648;
        {
          D.32649 = __s2_len != 0;
          D.32650 = __result == 0;
          D.32651 = D.32649 & D.32650;
          if (D.32651 != 0) goto <D.32652>; else goto <D.32653>;
          <D.32652>:
          D.32654 = &MEM[(void *)"explicit-null-checks" + 1B];
          D.32655 = *D.32654;
          D.32656 = (int) D.32655;
          D.32657 = __s2 + 1;
          D.32658 = *D.32657;
          D.32659 = (int) D.32658;
          __result = D.32656 - D.32659;
          D.32660 = __s2_len > 1;
          D.32650 = __result == 0;
          D.32661 = D.32660 & D.32650;
          if (D.32661 != 0) goto <D.32662>; else goto <D.32663>;
          <D.32662>:
          D.32664 = &MEM[(void *)"explicit-null-checks" + 2B];
          D.32665 = *D.32664;
          D.32666 = (int) D.32665;
          D.32667 = __s2 + 2;
          D.32668 = *D.32667;
          D.32669 = (int) D.32668;
          __result = D.32666 - D.32669;
          D.32670 = __s2_len > 2;
          D.32650 = __result == 0;
          D.32671 = D.32670 & D.32650;
          if (D.32671 != 0) goto <D.32672>; else goto <D.32673>;
          <D.32672>:
          D.32674 = &MEM[(void *)"explicit-null-checks" + 3B];
          D.32675 = *D.32674;
          D.32676 = (int) D.32675;
          D.32677 = __s2 + 3;
          D.32678 = *D.32677;
          D.32679 = (int) D.32678;
          __result = D.32676 - D.32679;
          <D.32673>:
          <D.32663>:
          <D.32653>:
        }
        D.26871 = __result;
      }
      iftmp.183 = -D.26871;
      goto <D.32680>;
      <D.32643>:
      iftmp.183 = __builtin_strcmp (arg, "explicit-null-checks");
      <D.32680>:
      D.26872 = iftmp.183;
    }
    if (D.26872 == 0) goto <D.32681>; else goto <D.32682>;
    <D.32681>:
    debug_options.explicit_null_checks = 1;
    goto <D.32683>;
    <D.32682>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 14;
      if (__s2_len <= 3) goto <D.32685>; else goto <D.32686>;
      <D.32685>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32687 = "gen-seq-points";
        D.32688 = MEM[(const unsigned char *)D.32687];
        D.32689 = (int) D.32688;
        D.32690 = *__s2;
        D.32691 = (int) D.32690;
        __result = D.32689 - D.32691;
        {
          D.32692 = __s2_len != 0;
          D.32693 = __result == 0;
          D.32694 = D.32692 & D.32693;
          if (D.32694 != 0) goto <D.32695>; else goto <D.32696>;
          <D.32695>:
          D.32697 = &MEM[(void *)"gen-seq-points" + 1B];
          D.32698 = *D.32697;
          D.32699 = (int) D.32698;
          D.32700 = __s2 + 1;
          D.32701 = *D.32700;
          D.32702 = (int) D.32701;
          __result = D.32699 - D.32702;
          D.32703 = __s2_len > 1;
          D.32693 = __result == 0;
          D.32704 = D.32703 & D.32693;
          if (D.32704 != 0) goto <D.32705>; else goto <D.32706>;
          <D.32705>:
          D.32707 = &MEM[(void *)"gen-seq-points" + 2B];
          D.32708 = *D.32707;
          D.32709 = (int) D.32708;
          D.32710 = __s2 + 2;
          D.32711 = *D.32710;
          D.32712 = (int) D.32711;
          __result = D.32709 - D.32712;
          D.32713 = __s2_len > 2;
          D.32693 = __result == 0;
          D.32714 = D.32713 & D.32693;
          if (D.32714 != 0) goto <D.32715>; else goto <D.32716>;
          <D.32715>:
          D.32717 = &MEM[(void *)"gen-seq-points" + 3B];
          D.32718 = *D.32717;
          D.32719 = (int) D.32718;
          D.32720 = __s2 + 3;
          D.32721 = *D.32720;
          D.32722 = (int) D.32721;
          __result = D.32719 - D.32722;
          <D.32716>:
          <D.32706>:
          <D.32696>:
        }
        D.26880 = __result;
      }
      iftmp.184 = -D.26880;
      goto <D.32723>;
      <D.32686>:
      iftmp.184 = __builtin_strcmp (arg, "gen-seq-points");
      <D.32723>:
      D.26881 = iftmp.184;
    }
    if (D.26881 == 0) goto <D.32724>; else goto <D.32725>;
    <D.32724>:
    debug_options.gen_seq_points = 1;
    goto <D.32726>;
    <D.32725>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 11;
      if (__s2_len <= 3) goto <D.32728>; else goto <D.32729>;
      <D.32728>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32730 = "init-stacks";
        D.32731 = MEM[(const unsigned char *)D.32730];
        D.32732 = (int) D.32731;
        D.32733 = *__s2;
        D.32734 = (int) D.32733;
        __result = D.32732 - D.32734;
        {
          D.32735 = __s2_len != 0;
          D.32736 = __result == 0;
          D.32737 = D.32735 & D.32736;
          if (D.32737 != 0) goto <D.32738>; else goto <D.32739>;
          <D.32738>:
          D.32740 = &MEM[(void *)"init-stacks" + 1B];
          D.32741 = *D.32740;
          D.32742 = (int) D.32741;
          D.32743 = __s2 + 1;
          D.32744 = *D.32743;
          D.32745 = (int) D.32744;
          __result = D.32742 - D.32745;
          D.32746 = __s2_len > 1;
          D.32736 = __result == 0;
          D.32747 = D.32746 & D.32736;
          if (D.32747 != 0) goto <D.32748>; else goto <D.32749>;
          <D.32748>:
          D.32750 = &MEM[(void *)"init-stacks" + 2B];
          D.32751 = *D.32750;
          D.32752 = (int) D.32751;
          D.32753 = __s2 + 2;
          D.32754 = *D.32753;
          D.32755 = (int) D.32754;
          __result = D.32752 - D.32755;
          D.32756 = __s2_len > 2;
          D.32736 = __result == 0;
          D.32757 = D.32756 & D.32736;
          if (D.32757 != 0) goto <D.32758>; else goto <D.32759>;
          <D.32758>:
          D.32760 = &MEM[(void *)"init-stacks" + 3B];
          D.32761 = *D.32760;
          D.32762 = (int) D.32761;
          D.32763 = __s2 + 3;
          D.32764 = *D.32763;
          D.32765 = (int) D.32764;
          __result = D.32762 - D.32765;
          <D.32759>:
          <D.32749>:
          <D.32739>:
        }
        D.26889 = __result;
      }
      iftmp.185 = -D.26889;
      goto <D.32766>;
      <D.32729>:
      iftmp.185 = __builtin_strcmp (arg, "init-stacks");
      <D.32766>:
      D.26890 = iftmp.185;
    }
    if (D.26890 == 0) goto <D.32767>; else goto <D.32768>;
    <D.32767>:
    debug_options.init_stacks = 1;
    goto <D.32769>;
    <D.32768>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.32771>; else goto <D.32772>;
      <D.32771>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32773 = "casts";
        D.32774 = MEM[(const unsigned char *)D.32773];
        D.32775 = (int) D.32774;
        D.32776 = *__s2;
        D.32777 = (int) D.32776;
        __result = D.32775 - D.32777;
        {
          D.32778 = __s2_len != 0;
          D.32779 = __result == 0;
          D.32780 = D.32778 & D.32779;
          if (D.32780 != 0) goto <D.32781>; else goto <D.32782>;
          <D.32781>:
          D.32783 = &MEM[(void *)"casts" + 1B];
          D.32784 = *D.32783;
          D.32785 = (int) D.32784;
          D.32786 = __s2 + 1;
          D.32787 = *D.32786;
          D.32788 = (int) D.32787;
          __result = D.32785 - D.32788;
          D.32789 = __s2_len > 1;
          D.32779 = __result == 0;
          D.32790 = D.32789 & D.32779;
          if (D.32790 != 0) goto <D.32791>; else goto <D.32792>;
          <D.32791>:
          D.32793 = &MEM[(void *)"casts" + 2B];
          D.32794 = *D.32793;
          D.32795 = (int) D.32794;
          D.32796 = __s2 + 2;
          D.32797 = *D.32796;
          D.32798 = (int) D.32797;
          __result = D.32795 - D.32798;
          D.32799 = __s2_len > 2;
          D.32779 = __result == 0;
          D.32800 = D.32799 & D.32779;
          if (D.32800 != 0) goto <D.32801>; else goto <D.32802>;
          <D.32801>:
          D.32803 = &MEM[(void *)"casts" + 3B];
          D.32804 = *D.32803;
          D.32805 = (int) D.32804;
          D.32806 = __s2 + 3;
          D.32807 = *D.32806;
          D.32808 = (int) D.32807;
          __result = D.32805 - D.32808;
          <D.32802>:
          <D.32792>:
          <D.32782>:
        }
        D.26898 = __result;
      }
      iftmp.186 = -D.26898;
      goto <D.32809>;
      <D.32772>:
      iftmp.186 = __builtin_strcmp (arg, "casts");
      <D.32809>:
      D.26899 = iftmp.186;
    }
    if (D.26899 == 0) goto <D.32810>; else goto <D.32811>;
    <D.32810>:
    debug_options.better_cast_details = 1;
    goto <D.32812>;
    <D.32811>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 16;
      if (__s2_len <= 3) goto <D.32814>; else goto <D.32815>;
      <D.32814>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.32816 = "soft-breakpoints";
        D.32817 = MEM[(const unsigned char *)D.32816];
        D.32818 = (int) D.32817;
        D.32819 = *__s2;
        D.32820 = (int) D.32819;
        __result = D.32818 - D.32820;
        {
          D.32821 = __s2_len != 0;
          D.32822 = __result == 0;
          D.32823 = D.32821 & D.32822;
          if (D.32823 != 0) goto <D.32824>; else goto <D.32825>;
          <D.32824>:
          D.32826 = &MEM[(void *)"soft-breakpoints" + 1B];
          D.32827 = *D.32826;
          D.32828 = (int) D.32827;
          D.32829 = __s2 + 1;
          D.32830 = *D.32829;
          D.32831 = (int) D.32830;
          __result = D.32828 - D.32831;
          D.32832 = __s2_len > 1;
          D.32822 = __result == 0;
          D.32833 = D.32832 & D.32822;
          if (D.32833 != 0) goto <D.32834>; else goto <D.32835>;
          <D.32834>:
          D.32836 = &MEM[(void *)"soft-breakpoints" + 2B];
          D.32837 = *D.32836;
          D.32838 = (int) D.32837;
          D.32839 = __s2 + 2;
          D.32840 = *D.32839;
          D.32841 = (int) D.32840;
          __result = D.32838 - D.32841;
          D.32842 = __s2_len > 2;
          D.32822 = __result == 0;
          D.32843 = D.32842 & D.32822;
          if (D.32843 != 0) goto <D.32844>; else goto <D.32845>;
          <D.32844>:
          D.32846 = &MEM[(void *)"soft-breakpoints" + 3B];
          D.32847 = *D.32846;
          D.32848 = (int) D.32847;
          D.32849 = __s2 + 3;
          D.32850 = *D.32849;
          D.32851 = (int) D.32850;
          __result = D.32848 - D.32851;
          <D.32845>:
          <D.32835>:
          <D.32825>:
        }
        D.26907 = __result;
      }
      iftmp.187 = -D.26907;
      goto <D.32852>;
      <D.32815>:
      iftmp.187 = __builtin_strcmp (arg, "soft-breakpoints");
      <D.32852>:
      D.26908 = iftmp.187;
    }
    if (D.26908 == 0) goto <D.32853>; else goto <D.32854>;
    <D.32853>:
    debug_options.soft_breakpoints = 1;
    goto <D.32855>;
    <D.32854>:
    stderr.188 = stderr;
    fprintf (stderr.188, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.188 = stderr;
    fprintf (stderr.188, "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.32855>:
    <D.32812>:
    <D.32769>:
    <D.32726>:
    <D.32683>:
    <D.32640>:
    <D.32597>:
    <D.32554>:
    <D.32511>:
    <D.32468>:
    <D.32425>:
    <D.32382>:
    <D.32339>:
    <D.32296>:
    <D.32253>:
    <D.32210>:
  }
  ptr = ptr + 8;
  <D.26910>:
  if (ptr != 0B) goto <D.32857>; else goto <D.26911>;
  <D.32857>:
  D.32858 = *ptr;
  if (D.32858 != 0B) goto <D.26909>; else goto <D.26911>;
  <D.26911>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32860;
  void (*<Tc2>) (void *) destructor.189;
  int D.32862;
  _Bool D.32863;

  destructor.189 = (void (*<Tc2>) (void *)) destructor;
  D.32862 = pthread_key_create (key, destructor.189);
  D.32863 = D.32862 == 0;
  D.32860 = (int) D.32863;
  return D.32860;
}


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.32865>; else goto <D.32866>;
  <D.32865>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32867>;
  <D.32866>:
  sig = 0B;
  <D.32867>:
  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)
{
  unsigned char D.32868;
  unsigned char D.32869;
  _Bool D.32870;
  long int D.32871;
  long int D.32872;
  short unsigned int D.32875;
  _Bool D.32876;
  long int D.32877;
  long int D.32878;
  short int emul_opcode_num.190;
  short int emul_opcode_alloced.191;
  int iftmp.192;
  short int D.32888;
  unsigned short D.32890;
  unsigned short emul_opcode_alloced.193;
  unsigned short D.32892;
  short int emul_opcode_alloced.194;
  long unsigned int D.32894;
  long unsigned int D.32895;
  struct MonoJitICallInfo * * emul_opcode_map.195;
  void * emul_opcode_map.196;
  long unsigned int D.32898;
  short int * emul_opcode_opcodes.197;
  void * emul_opcode_opcodes.198;
  long unsigned int D.32901;
  long unsigned int D.32902;
  struct MonoJitICallInfo * * D.32903;
  long unsigned int D.32904;
  short int * D.32905;
  short int D.32906;
  short int emul_opcode_num.199;
  unsigned short emul_opcode_num.200;
  unsigned short D.32909;
  short int emul_opcode_num.201;
  int D.32911;
  unsigned char D.32912;
  signed char D.32913;
  int D.32914;
  int D.32915;
  signed char D.32916;
  signed char D.32917;
  unsigned char D.32918;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.32868 = BIT_FIELD_REF <*sig, 8, 112>;
  D.32869 = D.32868 & 64;
  D.32870 = D.32869 != 0;
  D.32871 = (long int) D.32870;
  D.32872 = __builtin_expect (D.32871, 0);
  if (D.32872 != 0) goto <D.32873>; else goto <D.32874>;
  <D.32873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.32874>:
  D.32875 = sig->param_count;
  D.32876 = D.32875 > 2;
  D.32877 = (long int) D.32876;
  D.32878 = __builtin_expect (D.32877, 0);
  if (D.32878 != 0) goto <D.32879>; else goto <D.32880>;
  <D.32879>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.32880>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.190 = emul_opcode_num;
  emul_opcode_alloced.191 = emul_opcode_alloced;
  if (emul_opcode_num.190 >= emul_opcode_alloced.191) goto <D.32883>; else goto <D.32884>;
  <D.32883>:
  {
    int incr;

    emul_opcode_alloced.191 = emul_opcode_alloced;
    if (emul_opcode_alloced.191 != 0) goto <D.32886>; else goto <D.32887>;
    <D.32886>:
    emul_opcode_alloced.191 = emul_opcode_alloced;
    D.32888 = emul_opcode_alloced.191 / 2;
    iftmp.192 = (int) D.32888;
    goto <D.32889>;
    <D.32887>:
    iftmp.192 = 16;
    <D.32889>:
    incr = iftmp.192;
    D.32890 = (unsigned short) incr;
    emul_opcode_alloced.191 = emul_opcode_alloced;
    emul_opcode_alloced.193 = (unsigned short) emul_opcode_alloced.191;
    D.32892 = D.32890 + emul_opcode_alloced.193;
    emul_opcode_alloced.194 = (short int) D.32892;
    emul_opcode_alloced = emul_opcode_alloced.194;
    emul_opcode_alloced.191 = emul_opcode_alloced;
    D.32894 = (long unsigned int) emul_opcode_alloced.191;
    D.32895 = D.32894 * 8;
    emul_opcode_map.195 = emul_opcode_map;
    emul_opcode_map.196 = monoeg_realloc (emul_opcode_map.195, D.32895);
    emul_opcode_map = emul_opcode_map.196;
    emul_opcode_alloced.191 = emul_opcode_alloced;
    D.32894 = (long unsigned int) emul_opcode_alloced.191;
    D.32898 = D.32894 * 2;
    emul_opcode_opcodes.197 = emul_opcode_opcodes;
    emul_opcode_opcodes.198 = monoeg_realloc (emul_opcode_opcodes.197, D.32898);
    emul_opcode_opcodes = emul_opcode_opcodes.198;
  }
  <D.32884>:
  emul_opcode_map.195 = emul_opcode_map;
  emul_opcode_num.190 = emul_opcode_num;
  D.32901 = (long unsigned int) emul_opcode_num.190;
  D.32902 = D.32901 * 8;
  D.32903 = emul_opcode_map.195 + D.32902;
  *D.32903 = info;
  emul_opcode_opcodes.197 = emul_opcode_opcodes;
  emul_opcode_num.190 = emul_opcode_num;
  D.32901 = (long unsigned int) emul_opcode_num.190;
  D.32904 = D.32901 * 2;
  D.32905 = emul_opcode_opcodes.197 + D.32904;
  D.32906 = (short int) opcode;
  *D.32905 = D.32906;
  emul_opcode_num.190 = emul_opcode_num;
  emul_opcode_num.199 = emul_opcode_num.190;
  emul_opcode_num.200 = (unsigned short) emul_opcode_num.199;
  D.32909 = emul_opcode_num.200 + 1;
  emul_opcode_num.201 = (short int) D.32909;
  emul_opcode_num = emul_opcode_num.201;
  D.32911 = opcode >> 6;
  D.32911 = opcode >> 6;
  D.32912 = emul_opcode_hit_cache[D.32911];
  D.32913 = (signed char) D.32912;
  D.32914 = opcode & 7;
  D.32915 = 1 << D.32914;
  D.32916 = (signed char) D.32915;
  D.32917 = D.32913 | D.32916;
  D.32918 = (unsigned char) D.32917;
  emul_opcode_hit_cache[D.32911] = D.32918;
}


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

  if (sigstr != 0B) goto <D.32919>; else goto <D.32920>;
  <D.32919>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32921>;
  <D.32920>:
  sig = 0B;
  <D.32921>:
  if (save != 0) goto <D.32923>; else goto <D.32924>;
  <D.32923>:
  iftmp.202 = name;
  goto <D.32925>;
  <D.32924>:
  iftmp.202 = 0B;
  <D.32925>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.202);
}


mini_cleanup (struct MonoDomain * domain)
{
  unsigned int mono_jit_tls_id.203;
  void * D.32927;
  int mono_dont_free_global_codeman.204;
  struct MonoCodeManager * global_codeman.205;
  struct GHashTable * jit_icall_name_hash.206;
  struct MonoJitICallInfo * * emul_opcode_map.207;
  short int * emul_opcode_opcodes.208;
  void * * vtable_trampolines.209;
  struct _IO_FILE * stdout.210;
  struct MonoMethodDesc * mono_inject_async_exc_method.211;

  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.203 = mono_jit_tls_id;
  D.32927 = pthread_getspecific (mono_jit_tls_id.203);
  free_jit_tls_data (D.32927);
  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.204 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.204 == 0) goto <D.32929>; else goto <D.32930>;
  <D.32929>:
  global_codeman.205 = global_codeman;
  mono_code_manager_destroy (global_codeman.205);
  <D.32930>:
  jit_icall_name_hash.206 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.206);
  emul_opcode_map.207 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.207);
  emul_opcode_opcodes.208 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.208);
  vtable_trampolines.209 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.209);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.210 = stdout;
  mono_counters_dump (-1, stdout.210);
  mono_inject_async_exc_method.211 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.211 != 0B) goto <D.32938>; else goto <D.32939>;
  <D.32938>:
  mono_inject_async_exc_method.211 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.211);
  <D.32939>:
  mono_jit_tls_id.203 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.203);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.32940;
  char * D.32943;
  int D.32944;
  double D.32945;
  double D.32946;
  char * D.32947;
  int D.32948;
  long unsigned int D.32949;
  long unsigned int D.32950;
  long unsigned int D.32951;
  long unsigned int D.32952;
  long unsigned int D.32953;
  long unsigned int D.32954;
  long unsigned int D.32955;
  struct MonoImage * D.32956;
  struct MonoMemPool * D.32957;
  unsigned int D.32958;
  long unsigned int D.32959;
  long unsigned int D.32960;
  int D.32961;
  long unsigned int D.32962;
  long unsigned int D.32963;
  long unsigned int D.32964;
  long unsigned int D.32965;
  long unsigned int D.32966;
  long unsigned int D.32967;
  long unsigned int D.32968;
  long unsigned int D.32969;
  long unsigned int D.32970;
  long unsigned int D.32971;
  long unsigned int D.32972;
  long unsigned int D.32973;
  long unsigned int D.32974;
  long unsigned int D.32975;
  long unsigned int D.32976;
  long unsigned int D.32977;
  long unsigned int D.32978;
  long unsigned int D.32979;
  long unsigned int D.32980;
  <unnamed type> D.32981;
  int D.32984;
  int D.32985;
  int D.32986;
  int D.32987;
  int D.32988;
  int D.32989;

  D.32940 = mono_jit_stats.enabled;
  if (D.32940 != 0) goto <D.32941>; else goto <D.32942>;
  <D.32941>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.32943 = mono_jit_stats.max_ratio_method;
  D.32944 = mono_jit_stats.max_code_size_ratio;
  D.32945 = (double) D.32944;
  D.32946 = D.32945 / 1.0e+2;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.32946, D.32943);
  D.32947 = mono_jit_stats.biggest_method;
  D.32948 = mono_jit_stats.biggest_method_size;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.32948, D.32947);
  D.32949 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.32949);
  D.32950 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.32950);
  D.32951 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.32951);
  D.32952 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.32952);
  D.32953 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.32953);
  D.32954 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.32954);
  D.32955 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.32955);
  D.32956 = mono_defaults.corlib;
  D.32957 = D.32956->mempool;
  D.32958 = mono_mempool_get_allocated (D.32957);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.32958);
  D.32959 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.32959);
  D.32960 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.32960);
  D.32961 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.32961);
  D.32962 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.32962);
  D.32963 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.32963);
  D.32964 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.32964);
  D.32965 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.32965);
  D.32966 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.32966);
  D.32967 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.32967);
  D.32968 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.32968);
  D.32969 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.32969);
  D.32970 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.32970);
  D.32971 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.32971);
  D.32972 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.32972);
  D.32973 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.32973);
  D.32974 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.32974);
  D.32975 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.32975);
  D.32976 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.32976);
  D.32977 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.32977);
  D.32978 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.32978);
  D.32979 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.32979);
  D.32980 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.32980);
  D.32981 = mono_security_get_mode ();
  if (D.32981 == 2) goto <D.32982>; else goto <D.32983>;
  <D.32982>:
  D.32984 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.32984);
  D.32985 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.32985);
  D.32986 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.32986);
  D.32987 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.32987);
  D.32988 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.32988);
  D.32989 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.32989);
  <D.32983>:
  D.32943 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.32943);
  mono_jit_stats.max_ratio_method = 0B;
  D.32947 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.32947);
  mono_jit_stats.biggest_method = 0B;
  <D.32942>:
}


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);
}


mono_disable_optimizations (guint32 opts)
{
  unsigned int D.32990;
  unsigned int default_opt.212;
  unsigned int default_opt.213;

  D.32990 = ~opts;
  default_opt.212 = default_opt;
  default_opt.213 = D.32990 & default_opt.212;
  default_opt = default_opt.213;
}


mono_set_optimizations (guint32 opts)
{
  default_opt = opts;
  default_opt_set = 1;
}


mono_set_verbose_level (guint32 level)
{
  int level.214;

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


mono_get_runtime_build_info ()
{
  const char * mono_build_date.215;
  char * D.32997;

  mono_build_date.215 = mono_build_date;
  if (mono_build_date.215 != 0B) goto <D.32995>; else goto <D.32996>;
  <D.32995>:
  mono_build_date.215 = mono_build_date;
  D.32997 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.215);
  return D.32997;
  <D.32996>:
  D.32997 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.32997;
}


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.32999;
  int mini_verbose.216;
  const char * D.33005;
  int D.33006;
  int D.33007;
  unsigned int D.33008;
  short unsigned int D.33009;
  int D.33010;
  int D.33011;
  int D.27020;
  int iftmp.217;
  int D.27019;
  const char[9] * D.33019;
  unsigned char D.33020;
  int D.33021;
  unsigned char D.33022;
  int D.33023;
  _Bool D.33024;
  _Bool D.33025;
  _Bool D.33026;
  const unsigned char * D.33029;
  unsigned char D.33030;
  int D.33031;
  const unsigned char * D.33032;
  unsigned char D.33033;
  int D.33034;
  _Bool D.33035;
  _Bool D.33036;
  const unsigned char * D.33039;
  unsigned char D.33040;
  int D.33041;
  const unsigned char * D.33042;
  unsigned char D.33043;
  int D.33044;
  _Bool D.33045;
  _Bool D.33046;
  const unsigned char * D.33049;
  unsigned char D.33050;
  int D.33051;
  const unsigned char * D.33052;
  unsigned char D.33053;
  int D.33054;
  const char * D.33056;
  struct MonoClass * D.33059;
  unsigned char D.33060;
  unsigned char D.33061;
  struct MonoMethodSignature * D.33064;
  unsigned char D.33065;
  unsigned char D.33066;
  int D.33069;
  struct MonoAssembly * * D.33070;
  long unsigned int D.33071;
  long unsigned int D.33072;
  struct MonoAssembly * * D.33073;
  struct MonoAssembly * D.33074;
  int D.33077;
  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.32999 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.32999 != 0B) goto <D.33000>; else goto <D.33001>;
  <D.33000>:
  return;
  <D.33001>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.216 = mini_verbose;
  if (mini_verbose.216 > 0) goto <D.33003>; else goto <D.33004>;
  <D.33003>:
  D.33005 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.33005);
  <D.33004>:
  i = 0;
  goto <D.27022>;
  <D.27021>:
  D.33006 = i + 1;
  D.33007 = D.33006 | 100663296;
  D.33008 = (unsigned int) D.33007;
  method = mono_get_method (image, D.33008, 0B);
  D.33009 = method->flags;
  D.33010 = (int) D.33009;
  D.33011 = D.33010 & 1024;
  if (D.33011 != 0) goto <D.33012>; else goto <D.33013>;
  <D.33012>:
  // predicted unlikely by continue predictor.
  goto <D.27010>;
  <D.33013>:
  count = count + 1;
  mini_verbose.216 = mini_verbose;
  if (mini_verbose.216 > 1) goto <D.33014>; else goto <D.33015>;
  <D.33014>:
  {
    char * desc;

    desc = mono_method_full_name (method, 1);
    monoeg_g_print ("Compiling %d %s\n", count, desc);
    monoeg_g_free (desc);
  }
  <D.33015>:
  mono_compile_method (method);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.33017>; else goto <D.33018>;
    <D.33017>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.33019 = "Finalize";
      D.33020 = MEM[(const unsigned char *)D.33019];
      D.33021 = (int) D.33020;
      D.33022 = *__s2;
      D.33023 = (int) D.33022;
      __result = D.33021 - D.33023;
      {
        D.33024 = __s2_len != 0;
        D.33025 = __result == 0;
        D.33026 = D.33024 & D.33025;
        if (D.33026 != 0) goto <D.33027>; else goto <D.33028>;
        <D.33027>:
        D.33029 = &MEM[(void *)"Finalize" + 1B];
        D.33030 = *D.33029;
        D.33031 = (int) D.33030;
        D.33032 = __s2 + 1;
        D.33033 = *D.33032;
        D.33034 = (int) D.33033;
        __result = D.33031 - D.33034;
        D.33035 = __s2_len > 1;
        D.33025 = __result == 0;
        D.33036 = D.33035 & D.33025;
        if (D.33036 != 0) goto <D.33037>; else goto <D.33038>;
        <D.33037>:
        D.33039 = &MEM[(void *)"Finalize" + 2B];
        D.33040 = *D.33039;
        D.33041 = (int) D.33040;
        D.33042 = __s2 + 2;
        D.33043 = *D.33042;
        D.33044 = (int) D.33043;
        __result = D.33041 - D.33044;
        D.33045 = __s2_len > 2;
        D.33025 = __result == 0;
        D.33046 = D.33045 & D.33025;
        if (D.33046 != 0) goto <D.33047>; else goto <D.33048>;
        <D.33047>:
        D.33049 = &MEM[(void *)"Finalize" + 3B];
        D.33050 = *D.33049;
        D.33051 = (int) D.33050;
        D.33052 = __s2 + 3;
        D.33053 = *D.33052;
        D.33054 = (int) D.33053;
        __result = D.33051 - D.33054;
        <D.33048>:
        <D.33038>:
        <D.33028>:
      }
      D.27019 = __result;
    }
    iftmp.217 = -D.27019;
    goto <D.33055>;
    <D.33018>:
    D.33056 = method->name;
    iftmp.217 = __builtin_strcmp (D.33056, "Finalize");
    <D.33055>:
    D.27020 = iftmp.217;
  }
  if (D.27020 == 0) goto <D.33057>; else goto <D.33058>;
  <D.33057>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.33058>:
  D.33059 = method->klass;
  D.33060 = BIT_FIELD_REF <*D.33059, 8, 272>;
  D.33061 = D.33060 & 64;
  if (D.33061 != 0) goto <D.33062>; else goto <D.33063>;
  <D.33062>:
  D.33064 = mono_method_signature (method);
  D.33065 = BIT_FIELD_REF <*D.33064, 8, 112>;
  D.33066 = D.33065 & 64;
  if (D.33066 != 0) goto <D.33067>; else goto <D.33068>;
  <D.33067>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.33068>:
  <D.33063>:
  <D.27010>:
  i = i + 1;
  <D.27022>:
  D.33069 = mono_image_get_table_rows (image, 6);
  if (D.33069 > i) goto <D.27021>; else goto <D.27023>;
  <D.27023>:
  i = 0;
  goto <D.27025>;
  <D.27024>:
  mono_assembly_load_reference (image, i);
  D.33070 = image->references;
  D.33071 = (long unsigned int) i;
  D.33072 = D.33071 * 8;
  D.33073 = D.33070 + D.33072;
  D.33074 = *D.33073;
  if (D.33074 != 0B) goto <D.33075>; else goto <D.33076>;
  <D.33075>:
  D.33070 = image->references;
  D.33071 = (long unsigned int) i;
  D.33072 = D.33071 * 8;
  D.33073 = D.33070 + D.33072;
  D.33074 = *D.33073;
  mono_precompile_assembly (D.33074, assemblies);
  <D.33076>:
  i = i + 1;
  <D.27025>:
  D.33077 = mono_image_get_table_rows (image, 35);
  if (D.33077 > i) goto <D.27024>; else goto <D.27026>;
  <D.27026>:
}


mono_arch_instrument_epilog (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments)
{
  void * D.33079;

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


mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.33081;
  long int start.218;
  unsigned char * D.33083;
  long int D.33084;
  long int D.33085;
  int D.33086;
  struct GSList * D.33087;
  struct GSList * D.33088;
  struct TryBlockHole * hole;

  D.33081 = cfg->mempool;
  hole = mono_mempool_alloc (D.33081, 24);
  hole->clause = clause;
  start.218 = (long int) start;
  D.33083 = cfg->native_code;
  D.33084 = (long int) D.33083;
  D.33085 = start.218 - D.33084;
  D.33086 = (int) D.33085;
  hole->start_offset = D.33086;
  hole->basic_block = bb;
  D.33087 = cfg->try_block_holes;
  D.33081 = cfg->mempool;
  D.33088 = g_slist_append_mempool (D.33081, D.33087, hole);
  cfg->try_block_holes = D.33088;
}


mono_cfg_set_exception (struct MonoCompile * cfg, int type)
{
  unsigned int type.219;

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


mono_arch_gsharedvt_sig_supported (struct MonoMethodSignature * sig)
{
  gboolean D.33090;

  D.33090 = 0;
  return D.33090;
}


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.33092;

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


mono_arch_get_gsharedvt_arg_trampoline (struct MonoDomain * domain, void * arg, void * addr)
{
  void * D.33094;

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


mono_arch_get_gsharedvt_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.33096;

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


mini_replace_type (struct MonoType * type)
{
  struct MonoType * D.33098;

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