mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.27119;
  unsigned char * D.27120;
  unsigned int D.27121;
  long unsigned int D.27122;

  D.27120 = cfg->native_code;
  D.27121 = cfg->code_size;
  D.27122 = (long unsigned int) D.27121;
  D.27119 = monoeg_realloc (D.27120, D.27122);
  return D.27119;
}


mono_running_on_valgrind ()
{
  long long unsigned int D.25021;
  unsigned int D.27124;
  gboolean D.27127;

  {
    long long unsigned int _zzq_args[6];
    long long unsigned int _zzq_result;
    long long unsigned int * _zzq_ptr;

    try
      {
        _zzq_args[0] = 4097;
        _zzq_args[1] = 0;
        _zzq_args[2] = 0;
        _zzq_args[3] = 0;
        _zzq_args[4] = 0;
        _zzq_args[5] = 0;
        _zzq_ptr = &_zzq_args;
        __asm__ __volatile__("mr 3,%1
	mr 4,%2
	rotldi 0,0,3  ; rotldi 0,0,13
	rotldi 0,0,61 ; rotldi 0,0,51
	or 1,1,1
	mr %0,3" : "=b" _zzq_result : "b" 0, "b" _zzq_ptr : "r4", "r3", "memory", "cc");
        D.25021 = _zzq_result;
      }
    finally
      {
        _zzq_args = {CLOBBER};
      }
  }
  D.27124 = (unsigned int) D.25021;
  if (D.27124 != 0) goto <D.27125>; else goto <D.27126>;
  <D.27125>:
  D.27127 = 1;
  return D.27127;
  <D.27126>:
  D.27127 = 0;
  return D.27127;
}


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

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


get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.27135;
  _Bool D.27138;
  long int D.27139;
  long int D.27140;
  void * D.27143;
  struct GHashTable * D.27144;
  _Bool D.27147;
  long int D.27148;
  long int D.27149;
  struct MonoMethod * D.27152;
  char * D.27155;
  struct MonoMethod * D.27156;
  struct MonoMethod * D.27157;
  long int ip.0;
  void * D.27159;
  long int D.27160;
  long int D.27161;
  unsigned int D.27162;
  int D.27163;
  int D.27164;
  sizetype D.27165;
  char * D.27166;
  char * D.27167;
  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.27131>; else goto <D.27132>;
      <D.27131>:
      domain = mono_get_root_domain ();
      <D.27132>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.27133>; else goto <D.27134>;
      <D.27133>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

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

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

        D.27152 = user_data.method;
        mname = mono_method_full_name (D.27152, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.27155 = res;
        return D.27155;
      }
      <D.27154>:
      D.27155 = 0B;
      return D.27155;
      <D.27134>:
      D.27156 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27156, 1);
      D.27157 = jinfo_get_method (ji);
      ip.0 = (long int) ip;
      D.27159 = ji->code_start;
      D.27160 = (long int) D.27159;
      D.27161 = ip.0 - D.27160;
      D.27162 = (unsigned int) D.27161;
      location = mono_debug_lookup_source_location (D.27157, D.27162, domain);
      ip.0 = (long int) ip;
      D.27159 = ji->code_start;
      D.27160 = (long int) D.27159;
      D.27161 = ip.0 - D.27160;
      D.27163 = (int) D.27161;
      D.27159 = ji->code_start;
      D.27159 = ji->code_start;
      D.27164 = ji->code_size;
      D.27165 = (sizetype) D.27164;
      D.27166 = D.27159 + D.27165;
      D.27167 = domain->friendly_name;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.27163, D.27159, D.27166, domain, D.27167);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.27155 = res;
      return D.27155;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


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

  ud = user_data;
  D.27170 = ud->ip;
  if (D.27170 == value) goto <D.27171>; else goto <D.27172>;
  <D.27171>:
  ud->method = key;
  <D.27172>:
}


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

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


mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.27178;
  _Bool D.27181;
  long int D.27182;
  long int D.27183;
  void * D.27186;
  struct GHashTable * D.27187;
  _Bool D.27190;
  long int D.27191;
  long int D.27192;
  struct MonoMethod * D.27195;
  guint8 * D.27198;
  unsigned int D.27201;
  sizetype D.27202;
  guint8 * D.27203;
  long int ip.2;
  long int D.27207;
  long int D.27208;
  int D.27209;
  char * D.27210;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.27212;
  struct MonoMethod * D.27213;
  void * D.27214;
  long int D.27215;
  long int D.27216;
  unsigned int D.27217;
  struct MonoDomain * target_domain.4;
  gboolean * D.27224;
  gboolean * D.27226;
  int D.27227;
  int D.27228;
  sizetype D.27229;
  char * D.27230;
  char * D.27231;
  char * D.27234;
  unsigned int D.27235;
  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.27176>; else goto <D.27177>;
      <D.27176>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.27178 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.27178);
        if (ret != 0) goto <D.27179>; else goto <D.27180>;
        <D.27179>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27180>:
        D.27181 = ret != 0;
        D.27182 = (long int) D.27181;
        D.27183 = __builtin_expect (D.27182, 0);
        if (D.27183 != 0) goto <D.27184>; else goto <D.27185>;
        <D.27184>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.27185>:
      }
      D.27186 = domain->runtime_info;
      D.27187 = MEM[(struct MonoJitDomainInfo *)D.27186].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.27187, find_tramp, &user_data);
      {
        int ret;

        D.27178 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.27178);
        if (ret != 0) goto <D.27188>; else goto <D.27189>;
        <D.27188>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27189>:
        D.27190 = ret != 0;
        D.27191 = (long int) D.27190;
        D.27192 = __builtin_expect (D.27191, 0);
        if (D.27192 != 0) goto <D.27193>; else goto <D.27194>;
        <D.27193>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.27194>:
      }
      D.27195 = user_data.method;
      if (D.27195 != 0B) goto <D.27196>; else goto <D.27197>;
      <D.27196>:
      {
        char * mname;

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

        tinfo = l->data;
        D.27198 = tinfo->code;
        if (D.27198 <= ip) goto <D.27199>; else goto <D.27200>;
        <D.27199>:
        D.27198 = tinfo->code;
        D.27201 = tinfo->code_size;
        D.27202 = (sizetype) D.27201;
        D.27203 = D.27198 + D.27202;
        if (D.27203 >= ip) goto <D.27204>; else goto <D.27205>;
        <D.27204>:
        ip.2 = (long int) ip;
        D.27198 = tinfo->code;
        D.27207 = (long int) D.27198;
        D.27208 = ip.2 - D.27207;
        D.27209 = (int) D.27208;
        D.27210 = tinfo->name;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.27209, D.27210);
        return;
        <D.27205>:
        <D.27200>:
      }
      l = l->next;
      <D.25069>:
      if (l != 0B) goto <D.25068>; else goto <D.25070>;
      <D.25070>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.27177>:
      D.27212 = jinfo_get_method (ji);
      method = mono_method_full_name (D.27212, 1);
      D.27213 = jinfo_get_method (ji);
      ip.2 = (long int) ip;
      D.27214 = ji->code_start;
      D.27215 = (long int) D.27214;
      D.27216 = ip.2 - D.27215;
      D.27217 = (unsigned int) D.27216;
      target_domain.4 = target_domain;
      source = mono_debug_lookup_source_location (D.27213, D.27217, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.27219>; else goto <D.27220>;
      <D.27219>:
      D.27224 = gsctx->var_is_vt;
      if (D.27224 != 0B) goto <D.27221>; else goto <D.27225>;
      <D.27225>:
      D.27226 = gsctx->mvar_is_vt;
      if (D.27226 != 0B) goto <D.27221>; else goto <D.27222>;
      <D.27221>:
      shared_type = "gsharedvt ";
      goto <D.27223>;
      <D.27222>:
      shared_type = "gshared ";
      <D.27223>:
      <D.27220>:
      ip.2 = (long int) ip;
      D.27214 = ji->code_start;
      D.27215 = (long int) D.27214;
      D.27216 = ip.2 - D.27215;
      D.27227 = (int) D.27216;
      D.27214 = ji->code_start;
      D.27214 = ji->code_start;
      D.27228 = ji->code_size;
      D.27229 = (sizetype) D.27228;
      D.27230 = D.27214 + D.27229;
      target_domain.4 = target_domain;
      target_domain.4 = target_domain;
      D.27231 = target_domain.4->friendly_name;
      monoeg_g_print ("IP %p at offset 0x%x of %smethod %s (%p %p)[domain %p - %s]\n", ip, D.27227, shared_type, method, D.27214, D.27230, target_domain.4, D.27231);
      if (source != 0B) goto <D.27232>; else goto <D.27233>;
      <D.27232>:
      D.27234 = source->source_file;
      D.27235 = source->row;
      monoeg_g_print ("%s:%d\n", D.27234, D.27235);
      <D.27233>:
      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.27239;

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


mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  gboolean D.27244;
  long unsigned int D.27245;
  long unsigned int D.27246;
  long unsigned int D.27249;
  long unsigned int D.27250;
  struct MonoClass * D.27253;
  struct MonoClass * D.27254;
  const char * D.27257;
  char * D.27258;
  struct MonoMethod * cmethod;

  if (caller == 0B) goto <D.27241>; else goto <D.27243>;
  <D.27243>:
  if (callee == 0B) goto <D.27241>; else goto <D.27242>;
  <D.27241>:
  D.27244 = 0;
  return D.27244;
  <D.27242>:
  D.27245 = BIT_FIELD_REF <*caller, 64, 256>;
  D.27246 = D.27245 & 32768;
  if (D.27246 != 0) goto <D.27247>; else goto <D.27248>;
  <D.27247>:
  D.27249 = BIT_FIELD_REF <*callee, 64, 256>;
  D.27250 = D.27249 & 32768;
  if (D.27250 == 0) goto <D.27251>; else goto <D.27252>;
  <D.27251>:
  D.27244 = 0;
  return D.27244;
  <D.27252>:
  <D.27248>:
  cmethod = jinfo_get_method (caller);
  D.27253 = cmethod->klass;
  D.27254 = mono_defaults.appdomain_class;
  if (D.27253 == D.27254) goto <D.27255>; else goto <D.27256>;
  <D.27255>:
  D.27257 = cmethod->name;
  D.27258 = strstr (D.27257, "InvokeInDomain");
  if (D.27258 != 0B) goto <D.27259>; else goto <D.27260>;
  <D.27259>:
  D.27244 = 0;
  return D.27244;
  <D.27260>:
  <D.27256>:
  D.27244 = 1;
  return D.27244;
}


mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * global_codeman.7;
  void * D.27269;
  _Bool D.27272;
  long int D.27273;
  long int D.27274;
  _Bool D.27279;
  long int D.27280;
  long int D.27281;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.27263>; else goto <D.27264>;
  <D.27263>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.25080>:
  goto <D.25080>;
  <D.27264>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.27266>; else goto <D.27267>;
  <D.27266>:
  global_codeman.7 = mono_code_manager_new ();
  global_codeman = global_codeman.7;
  global_codeman.6 = global_codeman;
  D.27269 = mono_code_manager_reserve (global_codeman.6, size);
  return D.27269;
  <D.27267>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27270>; else goto <D.27271>;
    <D.27270>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27271>:
    D.27272 = ret != 0;
    D.27273 = (long int) D.27272;
    D.27274 = __builtin_expect (D.27273, 0);
    if (D.27274 != 0) goto <D.27275>; else goto <D.27276>;
    <D.27275>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.27276>:
  }
  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.27277>; else goto <D.27278>;
    <D.27277>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27278>:
    D.27279 = ret != 0;
    D.27280 = (long int) D.27279;
    D.27281 = __builtin_expect (D.27280, 0);
    if (D.27281 != 0) goto <D.27282>; else goto <D.27283>;
    <D.27282>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.27283>:
  }
  D.27269 = ptr;
  return D.27269;
}


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

  D.27285 = data;
  return D.27285;
}


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.27287;
  short unsigned int D.27288;
  unsigned int when.8;
  struct MonoUnwindOp * D.27290;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.27287 = (unsigned char) tag;
  op->op = D.27287;
  D.27288 = (short unsigned int) reg;
  op->reg = D.27288;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.27290 = op;
  return D.27290;
}


mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.27292;
  unsigned char D.27293;
  short unsigned int D.27294;
  unsigned int when.9;
  struct GSList * D.27296;
  struct GSList * D.27297;
  unsigned int D.27298;
  const char * D.27301;
  const char * D.27302;
  const char * D.27303;
  int D.27304;
  struct MonoUnwindOp * op;

  D.27292 = cfg->mempool;
  op = mono_mempool_alloc0 (D.27292, 12);
  D.27293 = (unsigned char) tag;
  op->op = D.27293;
  D.27294 = (short unsigned int) reg;
  op->reg = D.27294;
  op->val = val;
  when.9 = (unsigned int) when;
  op->when = when.9;
  D.27292 = cfg->mempool;
  D.27296 = cfg->unwind_ops;
  D.27297 = g_slist_append_mempool (D.27292, D.27296, op);
  cfg->unwind_ops = D.27297;
  D.27298 = cfg->verbose_level;
  if (D.27298 > 1) goto <D.27299>; else goto <D.27300>;
  <D.27299>:
  switch (tag) <default: <D.27305>, case 12: <D.25111>, case 13: <D.25113>, case 14: <D.25114>, case 128: <D.25115>>
  <D.25111>:
  D.27301 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.27301, val);
  goto <D.25112>;
  <D.25113>:
  D.27302 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.27302);
  goto <D.25112>;
  <D.25114>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.25112>;
  <D.25115>:
  D.27303 = mono_arch_regname (reg);
  D.27304 = -val;
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.27303, D.27304);
  goto <D.25112>;
  <D.27305>:
  <D.25112>:
  <D.27300>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.27308;
  struct GSList * D.27309;
  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.27306>; else goto <D.27307>;
  <D.27306>:
  last = list;
  goto <D.14612>;
  <D.14611>:
  last = last->next;
  <D.14612>:
  D.27308 = last->next;
  if (D.27308 != 0B) goto <D.14611>; else goto <D.14613>;
  <D.14613>:
  last->next = new_list;
  D.27309 = list;
  return D.27309;
  <D.27307>:
  D.27309 = new_list;
  return D.27309;
}


mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.27311;
  int D.27312;
  struct MonoGenericContext * D.27315;
  struct MonoJumpInfoToken * D.27316;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 32);
  res->image = image;
  res->token = token;
  D.27311 = context != 0B;
  D.27312 = (int) D.27311;
  res->has_context = D.27312;
  if (context != 0B) goto <D.27313>; else goto <D.27314>;
  <D.27313>:
  D.27315 = &res->context;
  memcpy (D.27315, context, 16);
  <D.27314>:
  D.27316 = res;
  return D.27316;
}


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

  D.27319 = __builtin_object_size (__dest, 0);
  D.27318 = __builtin___memcpy_chk (__dest, __src, __len, D.27319);
  return D.27318;
}


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

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


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

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


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

  if (str != 0B) goto <D.27326>; else goto <D.27327>;
  <D.27326>:
  D.27328 = __strdup (str);
  return D.27328;
  <D.27327>:
  D.27328 = 0B;
  return D.27328;
}


mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.27330;
  void * D.27331;
  struct GSList * D.27332;
  struct GSList * l;

  D.27330 = info->name;
  monoeg_g_free (D.27330);
  l = info->unwind_ops;
  goto <D.25141>;
  <D.25140>:
  D.27331 = l->data;
  monoeg_g_free (D.27331);
  l = l->next;
  <D.25141>:
  if (l != 0B) goto <D.25140>; else goto <D.25142>;
  <D.25142>:
  D.27332 = info->unwind_ops;
  monoeg_g_slist_free (D.27332);
  monoeg_g_free (info);
}


mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.27335;
  unsigned int D.27336;
  char * D.27337;
  gchar * D.27338;
  _Bool D.27341;
  long int D.27342;
  long int D.27343;
  struct GSList * tramp_infos.10;
  struct GSList * tramp_infos.11;
  _Bool D.27350;
  long int D.27351;
  long int D.27352;
  int D.27355;
  int D.27358;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.27333>; else goto <D.27334>;
  <D.27333>:
  return;
  <D.27334>:
  copy = monoeg_malloc0 (56);
  D.27335 = info->code;
  copy->code = D.27335;
  D.27336 = info->code_size;
  copy->code_size = D.27336;
  D.27337 = info->name;
  D.27338 = monoeg_strdup (D.27337);
  copy->name = D.27338;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27339>; else goto <D.27340>;
    <D.27339>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27340>:
    D.27341 = ret != 0;
    D.27342 = (long int) D.27341;
    D.27343 = __builtin_expect (D.27342, 0);
    if (D.27343 != 0) goto <D.27344>; else goto <D.27345>;
    <D.27344>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.27345>:
  }
  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.27348>; else goto <D.27349>;
    <D.27348>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27349>:
    D.27350 = ret != 0;
    D.27351 = (long int) D.27350;
    D.27352 = __builtin_expect (D.27351, 0);
    if (D.27352 != 0) goto <D.27353>; else goto <D.27354>;
    <D.27353>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.27354>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.27355 = mono_jit_map_is_enabled ();
  if (D.27355 != 0) goto <D.27356>; else goto <D.27357>;
  <D.27356>:
  D.27335 = info->code;
  D.27336 = info->code_size;
  D.27358 = (int) D.27336;
  D.27337 = info->name;
  mono_emit_jit_tramp (D.27335, D.27358, D.27337);
  <D.27357>:
  mono_tramp_info_free (info);
}


mono_debug_count ()
{
  int count.12;
  int count.13;
  const gchar * D.27362;
  gboolean D.27365;
  const gchar * D.27366;
  int D.27367;
  const gchar * D.27370;
  int D.27371;
  static int count = 0;

  count.12 = count;
  count.13 = count.12 + 1;
  count = count.13;
  D.27362 = monoeg_g_getenv ("COUNT");
  if (D.27362 == 0B) goto <D.27363>; else goto <D.27364>;
  <D.27363>:
  D.27365 = 1;
  return D.27365;
  <D.27364>:
  D.27366 = monoeg_g_getenv ("COUNT");
  D.27367 = atoi (D.27366);
  count.12 = count;
  if (D.27367 == count.12) goto <D.27368>; else goto <D.27369>;
  <D.27368>:
  break_count ();
  <D.27369>:
  D.27370 = monoeg_g_getenv ("COUNT");
  D.27371 = atoi (D.27370);
  count.12 = count;
  if (D.27371 < count.12) goto <D.27372>; else goto <D.27373>;
  <D.27372>:
  D.27365 = 0;
  return D.27365;
  <D.27373>:
  D.27365 = 1;
  return D.27365;
}


break_count ()
{

}


atoi (const char * __nptr)
{
  int D.27375;
  long int D.27376;

  D.27376 = strtol (__nptr, 0B, 10);
  D.27375 = (int) D.27376;
  return D.27375;
}


mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.27378;
  long unsigned int D.27379;
  long unsigned int D.27380;
  struct MonoBasicBlock * * D.27381;
  struct MonoBasicBlock * D.27382;
  short int D.27385;
  int D.27386;
  int pos.14;
  long unsigned int D.27392;
  long unsigned int D.27393;
  struct MonoBasicBlock * * D.27394;
  int D.27395;
  _Bool D.27396;
  long int D.27397;
  long int D.27398;
  short int D.27401;
  unsigned short D.27402;
  unsigned short D.27403;
  short int D.27404;
  struct MonoBasicBlock * * D.27405;
  struct MonoBasicBlock * * D.27406;
  struct MonoBasicBlock * D.27407;
  short int D.27410;
  int D.27411;
  int pos.15;
  long unsigned int D.27417;
  long unsigned int D.27418;
  struct MonoBasicBlock * * D.27419;
  int D.27420;
  _Bool D.27421;
  long int D.27422;
  long int D.27423;
  short int D.27426;
  unsigned short D.27427;
  unsigned short D.27428;
  short int D.27429;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.25166>;
  <D.25165>:
  D.27378 = from->out_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27381 = D.27378 + D.27380;
  D.27382 = *D.27381;
  if (D.27382 == to) goto <D.27383>; else goto <D.27384>;
  <D.27383>:
  found = 1;
  goto <D.25164>;
  <D.27384>:
  i = i + 1;
  <D.25166>:
  D.27385 = from->out_count;
  D.27386 = (int) D.27385;
  if (D.27386 > i) goto <D.25165>; else goto <D.25164>;
  <D.25164>:
  if (found != 0) goto <D.27387>; else goto <D.27388>;
  <D.27387>:
  pos = 0;
  i = 0;
  goto <D.25168>;
  <D.25167>:
  D.27378 = from->out_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27381 = D.27378 + D.27380;
  D.27382 = *D.27381;
  if (D.27382 != to) goto <D.27389>; else goto <D.27390>;
  <D.27389>:
  D.27378 = from->out_bb;
  pos.14 = pos;
  pos = pos.14 + 1;
  D.27392 = (long unsigned int) pos.14;
  D.27393 = D.27392 * 8;
  D.27394 = D.27378 + D.27393;
  D.27378 = from->out_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27381 = D.27378 + D.27380;
  D.27382 = *D.27381;
  *D.27394 = D.27382;
  <D.27390>:
  i = i + 1;
  <D.25168>:
  D.27385 = from->out_count;
  D.27386 = (int) D.27385;
  if (D.27386 > i) goto <D.25167>; else goto <D.25169>;
  <D.25169>:
  D.27385 = from->out_count;
  D.27386 = (int) D.27385;
  D.27395 = D.27386 + -1;
  D.27396 = D.27395 != pos;
  D.27397 = (long int) D.27396;
  D.27398 = __builtin_expect (D.27397, 0);
  if (D.27398 != 0) goto <D.27399>; else goto <D.27400>;
  <D.27399>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.27400>:
  D.27385 = from->out_count;
  D.27401 = D.27385;
  D.27402 = (unsigned short) D.27401;
  D.27403 = D.27402 + 65535;
  D.27404 = (short int) D.27403;
  from->out_count = D.27404;
  <D.27388>:
  found = 0;
  i = 0;
  goto <D.25172>;
  <D.25171>:
  D.27405 = to->in_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27406 = D.27405 + D.27380;
  D.27407 = *D.27406;
  if (D.27407 == from) goto <D.27408>; else goto <D.27409>;
  <D.27408>:
  found = 1;
  goto <D.25170>;
  <D.27409>:
  i = i + 1;
  <D.25172>:
  D.27410 = to->in_count;
  D.27411 = (int) D.27410;
  if (D.27411 > i) goto <D.25171>; else goto <D.25170>;
  <D.25170>:
  if (found != 0) goto <D.27412>; else goto <D.27413>;
  <D.27412>:
  pos = 0;
  i = 0;
  goto <D.25174>;
  <D.25173>:
  D.27405 = to->in_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27406 = D.27405 + D.27380;
  D.27407 = *D.27406;
  if (D.27407 != from) goto <D.27414>; else goto <D.27415>;
  <D.27414>:
  D.27405 = to->in_bb;
  pos.15 = pos;
  pos = pos.15 + 1;
  D.27417 = (long unsigned int) pos.15;
  D.27418 = D.27417 * 8;
  D.27419 = D.27405 + D.27418;
  D.27405 = to->in_bb;
  D.27379 = (long unsigned int) i;
  D.27380 = D.27379 * 8;
  D.27406 = D.27405 + D.27380;
  D.27407 = *D.27406;
  *D.27419 = D.27407;
  <D.27415>:
  i = i + 1;
  <D.25174>:
  D.27410 = to->in_count;
  D.27411 = (int) D.27410;
  if (D.27411 > i) goto <D.25173>; else goto <D.25175>;
  <D.25175>:
  D.27410 = to->in_count;
  D.27411 = (int) D.27410;
  D.27420 = D.27411 + -1;
  D.27421 = D.27420 != pos;
  D.27422 = (long int) D.27421;
  D.27423 = __builtin_expect (D.27422, 0);
  if (D.27423 != 0) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.27425>:
  D.27410 = to->in_count;
  D.27426 = D.27410;
  D.27427 = (unsigned short) D.27426;
  D.27428 = D.27427 + 65535;
  D.27429 = (short int) D.27428;
  to->in_count = D.27429;
  <D.27413>:
}


mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.27430;
  long unsigned int D.27431;
  long unsigned int D.27432;
  struct MonoBasicBlock * * D.27433;
  struct MonoBasicBlock * D.27434;
  gboolean D.27437;
  short int D.27438;
  int D.27439;
  int i;

  i = 0;
  goto <D.25182>;
  <D.25181>:
  D.27430 = bb1->out_bb;
  D.27431 = (long unsigned int) i;
  D.27432 = D.27431 * 8;
  D.27433 = D.27430 + D.27432;
  D.27434 = *D.27433;
  if (D.27434 == bb2) goto <D.27435>; else goto <D.27436>;
  <D.27435>:
  D.27437 = 1;
  return D.27437;
  <D.27436>:
  i = i + 1;
  <D.25182>:
  D.27438 = bb1->out_count;
  D.27439 = (int) D.27438;
  if (D.27439 > i) goto <D.25181>; else goto <D.25183>;
  <D.25183>:
  D.27437 = 0;
  return D.27437;
}


mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.27441;
  int D.27444;
  int iftmp.16;
  <unnamed-unsigned:15> D.27450;
  int D.27451;
  _Bool D.27452;
  long int D.27453;
  long int D.27454;
  struct MonoExceptionClause * D.27457;
  long unsigned int D.27458;
  long unsigned int D.27459;
  struct MonoExceptionClause * D.27460;
  unsigned int D.27461;
  int D.27462;
  int D.27463;

  D.27441 = region & 240;
  if (D.27441 == 0) goto <D.27442>; else goto <D.27443>;
  <D.27442>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.27444 = region >> 8;
    clause_index = D.27444 + -1;
    if (clause_index < 0) goto <D.27446>; else goto <D.27449>;
    <D.27449>:
    D.27450 = header->num_clauses;
    D.27451 = (int) D.27450;
    if (D.27451 <= clause_index) goto <D.27446>; else goto <D.27447>;
    <D.27446>:
    iftmp.16 = 1;
    goto <D.27448>;
    <D.27447>:
    iftmp.16 = 0;
    <D.27448>:
    D.27452 = iftmp.16 != 0;
    D.27453 = (long int) D.27452;
    D.27454 = __builtin_expect (D.27453, 0);
    if (D.27454 != 0) goto <D.27455>; else goto <D.27456>;
    <D.27455>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.27456>:
    D.27457 = header->clauses;
    D.27458 = (long unsigned int) clause_index;
    D.27459 = D.27458 * 32;
    D.27460 = D.27457 + D.27459;
    D.27461 = D.27460->try_offset;
    D.27462 = (int) D.27461;
    region = mono_find_block_region_notry (cfg, D.27462);
  }
  <D.27443>:
  D.27463 = region;
  return D.27463;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.27465;
  long unsigned int D.27466;
  long unsigned int D.27467;
  unsigned int D.27468;
  unsigned int offset.17;
  unsigned int D.27472;
  unsigned int D.27475;
  int D.27478;
  int D.27479;
  int D.27480;
  unsigned int D.27481;
  unsigned int D.27482;
  unsigned int D.27483;
  unsigned int D.27486;
  unsigned int D.27487;
  unsigned int D.27492;
  unsigned int D.27495;
  unsigned int D.27496;
  <unnamed-unsigned:15> D.27497;
  int D.27498;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.25192>;
  <D.25191>:
  D.27465 = header->clauses;
  D.27466 = (long unsigned int) i;
  D.27467 = D.27466 * 32;
  clause = D.27465 + D.27467;
  D.27468 = clause->flags;
  if (D.27468 == 1) goto <D.27469>; else goto <D.27470>;
  <D.27469>:
  offset.17 = (unsigned int) offset;
  D.27472 = clause->data.filter_offset;
  if (offset.17 >= D.27472) goto <D.27473>; else goto <D.27474>;
  <D.27473>:
  offset.17 = (unsigned int) offset;
  D.27475 = clause->handler_offset;
  if (offset.17 < D.27475) goto <D.27476>; else goto <D.27477>;
  <D.27476>:
  D.27479 = i + 1;
  D.27480 = D.27479 << 8;
  D.27481 = (unsigned int) D.27480;
  D.27468 = clause->flags;
  D.27482 = D.27481 | D.27468;
  D.27483 = D.27482 | 128;
  D.27478 = (int) D.27483;
  return D.27478;
  <D.27477>:
  <D.27474>:
  <D.27470>:
  D.27475 = clause->handler_offset;
  offset.17 = (unsigned int) offset;
  if (D.27475 <= offset.17) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  offset.17 = (unsigned int) offset;
  D.27475 = clause->handler_offset;
  D.27486 = clause->handler_len;
  D.27487 = D.27475 + D.27486;
  if (offset.17 < D.27487) goto <D.27488>; else goto <D.27489>;
  <D.27488>:
  D.27468 = clause->flags;
  if (D.27468 == 2) goto <D.27490>; else goto <D.27491>;
  <D.27490>:
  D.27479 = i + 1;
  D.27480 = D.27479 << 8;
  D.27481 = (unsigned int) D.27480;
  D.27468 = clause->flags;
  D.27482 = D.27481 | D.27468;
  D.27492 = D.27482 | 16;
  D.27478 = (int) D.27492;
  return D.27478;
  <D.27491>:
  D.27468 = clause->flags;
  if (D.27468 == 4) goto <D.27493>; else goto <D.27494>;
  <D.27493>:
  D.27479 = i + 1;
  D.27480 = D.27479 << 8;
  D.27481 = (unsigned int) D.27480;
  D.27468 = clause->flags;
  D.27482 = D.27481 | D.27468;
  D.27495 = D.27482 | 64;
  D.27478 = (int) D.27495;
  return D.27478;
  <D.27494>:
  D.27479 = i + 1;
  D.27480 = D.27479 << 8;
  D.27481 = (unsigned int) D.27480;
  D.27468 = clause->flags;
  D.27482 = D.27481 | D.27468;
  D.27496 = D.27482 | 32;
  D.27478 = (int) D.27496;
  return D.27478;
  <D.27489>:
  <D.27485>:
  i = i + 1;
  <D.25192>:
  D.27497 = header->num_clauses;
  D.27498 = (int) D.27497;
  if (D.27498 > i) goto <D.25191>; else goto <D.25193>;
  <D.25193>:
  D.27478 = -1;
  return D.27478;
}


mono_find_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct MonoInst * D.27500;
  struct GHashTable * D.27501;
  long int D.27502;
  const void * D.27503;

  region = mono_get_block_region_notry (cfg, region);
  D.27501 = cfg->spvars;
  D.27502 = (long int) region;
  D.27503 = (const void *) D.27502;
  D.27500 = monoeg_g_hash_table_lookup (D.27501, D.27503);
  return D.27500;
}


mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.27505;
  int D.27508;
  unsigned int D.27510;
  int D.27513;
  unsigned int D.27515;
  int D.27518;
  unsigned int D.27520;
  int D.27523;
  guint32 D.27525;
  static const int reverse_map[10] = {64, 63, 62, 61, 60, 59, 68, 67, 66, 65};
  static const int reverse_fmap[10] = {663, 662, 661, 660, 659, 658, 667, 666, 665, 664};
  static const int reverse_lmap[10] = {556, 555, 554, 553, 552, 551, 560, 559, 558, 557};
  static const int reverse_imap[10] = {653, 652, 651, 650, 649, 648, 657, 656, 655, 654};

  D.27505 = opcode + 4294967237;
  if (D.27505 <= 9) goto <D.27506>; else goto <D.27507>;
  <D.27506>:
  D.27505 = opcode + 4294967237;
  D.27508 = reverse_map[D.27505];
  opcode = (guint32) D.27508;
  goto <D.27509>;
  <D.27507>:
  D.27510 = opcode + 4294966638;
  if (D.27510 <= 9) goto <D.27511>; else goto <D.27512>;
  <D.27511>:
  D.27510 = opcode + 4294966638;
  D.27513 = reverse_fmap[D.27510];
  opcode = (guint32) D.27513;
  goto <D.27514>;
  <D.27512>:
  D.27515 = opcode + 4294966745;
  if (D.27515 <= 9) goto <D.27516>; else goto <D.27517>;
  <D.27516>:
  D.27515 = opcode + 4294966745;
  D.27518 = reverse_lmap[D.27515];
  opcode = (guint32) D.27518;
  goto <D.27519>;
  <D.27517>:
  D.27520 = opcode + 4294966648;
  if (D.27520 <= 9) goto <D.27521>; else goto <D.27522>;
  <D.27521>:
  D.27520 = opcode + 4294966648;
  D.27523 = reverse_imap[D.27520];
  opcode = (guint32) D.27523;
  goto <D.27524>;
  <D.27522>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.27524>:
  <D.27519>:
  <D.27514>:
  <D.27509>:
  D.27525 = opcode;
  return D.27525;
}


mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.27527;
  long unsigned int D.27528;
  guint D.27531;
  unsigned char D.27532;
  int D.27533;
  struct MonoClass * D.27534;
  long unsigned int D.27535;
  long unsigned int D.27536;
  struct MonoGenericClass * D.27541;
  struct MonoClass * D.27542;
  int D.27543;
  void handle_enum = <<< error >>>;

  D.27527 = BIT_FIELD_REF <*type, 64, 64>;
  D.27528 = D.27527 & 1073741824;
  if (D.27528 != 0) goto <D.27529>; else goto <D.27530>;
  <D.27529>:
  D.27531 = 374;
  return D.27531;
  <D.27530>:
  type = mini_replace_type (type);
  handle_enum:
  D.27532 = type->type;
  D.27533 = (int) D.27532;
  switch (D.27533) <default: <D.25252>, case 2: <D.25228>, case 3: <D.25231>, case 4: <D.25226>, case 5: <D.25227>, case 6: <D.25229>, case 7: <D.25230>, case 8: <D.25232>, case 9: <D.25233>, case 10: <D.25243>, case 11: <D.25244>, case 12: <D.25245>, case 13: <D.25246>, case 14: <D.25239>, case 15: <D.25236>, case 17: <D.25247>, case 18: <D.25238>, case 19: <D.25250>, case 20: <D.25242>, case 21: <D.25249>, case 22: <D.25248>, case 24: <D.25234>, case 25: <D.25235>, case 27: <D.25237>, case 28: <D.25240>, case 29: <D.25241>, case 30: <D.25251>>
  <D.25226>:
  <D.25227>:
  <D.25228>:
  D.27531 = 375;
  return D.27531;
  <D.25229>:
  <D.25230>:
  <D.25231>:
  D.27531 = 376;
  return D.27531;
  <D.25232>:
  <D.25233>:
  D.27531 = 377;
  return D.27531;
  <D.25234>:
  <D.25235>:
  <D.25236>:
  <D.25237>:
  D.27531 = 374;
  return D.27531;
  <D.25238>:
  <D.25239>:
  <D.25240>:
  <D.25241>:
  <D.25242>:
  D.27531 = 374;
  return D.27531;
  <D.25243>:
  <D.25244>:
  D.27531 = 378;
  return D.27531;
  <D.25245>:
  D.27531 = 379;
  return D.27531;
  <D.25246>:
  D.27531 = 380;
  return D.27531;
  <D.25247>:
  D.27534 = type->data.klass;
  D.27535 = BIT_FIELD_REF <*D.27534, 64, 256>;
  D.27536 = D.27535 & 16;
  if (D.27536 != 0) goto <D.27537>; else goto <D.27538>;
  <D.27537>:
  D.27534 = type->data.klass;
  type = mono_class_enum_basetype (D.27534);
  goto handle_enum;
  <D.27538>:
  if (0 != 0) goto <D.27539>; else goto <D.27540>;
  <D.27539>:
  D.27531 = 386;
  return D.27531;
  <D.27540>:
  D.27531 = 387;
  return D.27531;
  <D.25248>:
  D.27531 = 387;
  return D.27531;
  <D.25249>:
  D.27541 = type->data.generic_class;
  D.27542 = D.27541->container_class;
  type = &D.27542->byval_arg;
  goto handle_enum;
  <D.25250>:
  <D.25251>:
  D.27543 = mini_type_var_is_vt (cfg, type);
  if (D.27543 != 0) goto <D.27544>; else goto <D.27545>;
  <D.27544>:
  D.27531 = 387;
  return D.27531;
  <D.27545>:
  D.27531 = 374;
  return D.27531;
  <D.25252>:
  D.27532 = type->type;
  D.27533 = (int) D.27532;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.27533);
  <D.25253>:
  goto <D.25253>;
  D.27531 = 4294967295;
  return D.27531;
}


mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.27547;
  long unsigned int D.27548;
  guint D.27551;
  unsigned char D.27552;
  int D.27553;
  int D.27556;
  struct MonoGenericSharingContext * D.27559;
  _Bool D.27560;
  long int D.27561;
  long int D.27562;
  int D.27565;

  D.27547 = BIT_FIELD_REF <*type, 64, 64>;
  D.27548 = D.27547 & 1073741824;
  if (D.27548 != 0) goto <D.27549>; else goto <D.27550>;
  <D.27549>:
  D.27551 = 388;
  return D.27551;
  <D.27550>:
  type = mini_replace_type (type);
  D.27552 = type->type;
  D.27553 = (int) D.27552;
  switch (D.27553) <default: <D.25284>, case 2: <D.25260>, case 3: <D.25263>, case 4: <D.25258>, case 5: <D.25259>, case 6: <D.25261>, case 7: <D.25262>, case 8: <D.25264>, case 9: <D.25265>, case 10: <D.25275>, case 11: <D.25276>, case 12: <D.25277>, case 13: <D.25278>, case 14: <D.25271>, case 15: <D.25268>, case 17: <D.25279>, case 18: <D.25270>, case 19: <D.25282>, case 20: <D.25274>, case 21: <D.25281>, case 22: <D.25280>, case 24: <D.25266>, case 25: <D.25267>, case 27: <D.25269>, case 28: <D.25272>, case 29: <D.25273>, case 30: <D.25283>>
  <D.25258>:
  D.27551 = 389;
  return D.27551;
  <D.25259>:
  <D.25260>:
  D.27551 = 390;
  return D.27551;
  <D.25261>:
  D.27551 = 391;
  return D.27551;
  <D.25262>:
  <D.25263>:
  D.27551 = 392;
  return D.27551;
  <D.25264>:
  D.27551 = 393;
  return D.27551;
  <D.25265>:
  D.27551 = 394;
  return D.27551;
  <D.25266>:
  <D.25267>:
  <D.25268>:
  <D.25269>:
  D.27551 = 388;
  return D.27551;
  <D.25270>:
  <D.25271>:
  <D.25272>:
  <D.25273>:
  <D.25274>:
  D.27551 = 388;
  return D.27551;
  <D.25275>:
  <D.25276>:
  D.27551 = 395;
  return D.27551;
  <D.25277>:
  D.27551 = 396;
  return D.27551;
  <D.25278>:
  D.27551 = 397;
  return D.27551;
  <D.25279>:
  if (0 != 0) goto <D.27554>; else goto <D.27555>;
  <D.27554>:
  D.27551 = 398;
  return D.27551;
  <D.27555>:
  <D.25280>:
  D.27551 = 399;
  return D.27551;
  <D.25281>:
  D.27556 = mono_type_generic_inst_is_valuetype (type);
  if (D.27556 != 0) goto <D.27557>; else goto <D.27558>;
  <D.27557>:
  D.27551 = 399;
  return D.27551;
  <D.27558>:
  D.27551 = 388;
  return D.27551;
  <D.25282>:
  <D.25283>:
  D.27559 = cfg->generic_sharing_context;
  D.27560 = D.27559 == 0B;
  D.27561 = (long int) D.27560;
  D.27562 = __builtin_expect (D.27561, 0);
  if (D.27562 != 0) goto <D.27563>; else goto <D.27564>;
  <D.27563>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.27564>:
  D.27565 = mini_type_var_is_vt (cfg, type);
  if (D.27565 != 0) goto <D.27566>; else goto <D.27567>;
  <D.27566>:
  D.27551 = 399;
  return D.27551;
  <D.27567>:
  D.27551 = 388;
  return D.27551;
  <D.25284>:
  D.27552 = type->type;
  D.27553 = (int) D.27552;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.27553);
  <D.25285>:
  goto <D.25285>;
  D.27551 = 4294967295;
  return D.27551;
}


mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27569;
  long unsigned int D.27572;
  long unsigned int D.27573;
  unsigned char D.27578;
  int D.27580;
  guint D.27583;

  type = mini_replace_type (type);
  D.27569 = cfg->generic_sharing_context;
  if (D.27569 != 0B) goto <D.27570>; else goto <D.27571>;
  <D.27570>:
  D.27572 = BIT_FIELD_REF <*type, 64, 64>;
  D.27573 = D.27572 & 1073741824;
  if (D.27573 == 0) goto <D.27574>; else goto <D.27575>;
  <D.27574>:
  D.27578 = type->type;
  if (D.27578 == 19) goto <D.27576>; else goto <D.27579>;
  <D.27579>:
  D.27578 = type->type;
  if (D.27578 == 30) goto <D.27576>; else goto <D.27577>;
  <D.27576>:
  D.27580 = mini_type_var_is_vt (cfg, type);
  if (D.27580 != 0) goto <D.27581>; else goto <D.27582>;
  <D.27581>:
  D.27583 = 129;
  return D.27583;
  <D.27582>:
  D.27583 = 81;
  return D.27583;
  <D.27577>:
  <D.27575>:
  <D.27571>:
  D.27583 = mono_type_to_stind (type);
  return D.27583;
}


mono_op_imm_to_op (int opcode)
{
  int D.27585;
  const char * D.27586;

  switch (opcode) <default: <D.25333>, case 323: <D.25330>, case 327: <D.25331>, case 339: <D.25332>, case 429: <D.25297>, case 432: <D.25322>, case 434: <D.25323>, case 436: <D.25303>, case 437: <D.25304>, case 438: <D.25305>, case 538: <D.25299>, case 539: <D.25301>, case 541: <D.25307>, case 542: <D.25309>, case 543: <D.25311>, case 544: <D.25313>, case 545: <D.25315>, case 546: <D.25317>, case 620: <D.25328>, case 622: <D.25329>, case 625: <D.25298>, case 626: <D.25300>, case 627: <D.25302>, case 628: <D.25318>, case 629: <D.25319>, case 630: <D.25321>, case 631: <D.25320>, case 632: <D.25306>, case 633: <D.25308>, case 634: <D.25310>, case 635: <D.25312>, case 636: <D.25314>, case 637: <D.25316>, case 752: <D.25325>, case 754: <D.25327>, case 756: <D.25324>, case 758: <D.25326>>
  <D.25297>:
  D.27585 = 479;
  return D.27585;
  <D.25298>:
  D.27585 = 565;
  return D.27585;
  <D.25299>:
  D.27585 = 479;
  return D.27585;
  <D.25300>:
  D.27585 = 566;
  return D.27585;
  <D.25301>:
  D.27585 = 480;
  return D.27585;
  <D.25302>:
  D.27585 = 567;
  return D.27585;
  <D.25303>:
  D.27585 = 486;
  return D.27585;
  <D.25304>:
  D.27585 = 487;
  return D.27585;
  <D.25305>:
  D.27585 = 488;
  return D.27585;
  <D.25306>:
  D.27585 = 572;
  return D.27585;
  <D.25307>:
  D.27585 = 486;
  return D.27585;
  <D.25308>:
  D.27585 = 573;
  return D.27585;
  <D.25309>:
  D.27585 = 487;
  return D.27585;
  <D.25310>:
  D.27585 = 574;
  return D.27585;
  <D.25311>:
  D.27585 = 488;
  return D.27585;
  <D.25312>:
  D.27585 = 575;
  return D.27585;
  <D.25313>:
  D.27585 = 489;
  return D.27585;
  <D.25314>:
  D.27585 = 576;
  return D.27585;
  <D.25315>:
  D.27585 = 490;
  return D.27585;
  <D.25316>:
  D.27585 = 577;
  return D.27585;
  <D.25317>:
  D.27585 = 491;
  return D.27585;
  <D.25318>:
  D.27585 = 568;
  return D.27585;
  <D.25319>:
  D.27585 = 569;
  return D.27585;
  <D.25320>:
  D.27585 = 571;
  return D.27585;
  <D.25321>:
  D.27585 = 570;
  return D.27585;
  <D.25322>:
  D.27585 = 482;
  return D.27585;
  <D.25323>:
  D.27585 = 484;
  return D.27585;
  <D.25324>:
  D.27585 = 755;
  return D.27585;
  <D.25325>:
  D.27585 = 751;
  return D.27585;
  <D.25326>:
  D.27585 = 757;
  return D.27585;
  <D.25327>:
  D.27585 = 753;
  return D.27585;
  <D.25328>:
  D.27585 = 619;
  return D.27585;
  <D.25329>:
  D.27585 = 621;
  return D.27585;
  <D.25330>:
  D.27585 = 322;
  return D.27585;
  <D.25331>:
  D.27585 = 326;
  return D.27585;
  <D.25332>:
  D.27585 = 338;
  return D.27585;
  <D.25333>:
  D.27586 = mono_inst_name (opcode);
  printf ("%s\n", D.27586);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.27585 = -1;
  return D.27585;
}


mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.27588;
  long int D.27589;
  struct MonoInst * D.27590;
  int D.27591;
  int D.27592;
  const unsigned char * D.27593;
  long int D.27594;
  unsigned int D.27595;
  int D.27596;
  short unsigned int D.27597;
  int D.27598;
  int D.27599;
  short unsigned int D.27600;
  int D.27603;
  unsigned int D.27605;
  unsigned int D.27606;
  unsigned int D.27607;
  struct MonoInst * temp;

  D.27588 = cfg->mempool;
  temp = mono_mempool_alloc (D.27588, 80);
  temp->data.op[1].const_val = 0;
  D.27589 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.27589;
  temp->prev = 0B;
  D.27590 = temp->prev;
  temp->next = D.27590;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.27591 = temp->sreg3;
  temp->sreg2 = D.27591;
  D.27592 = temp->sreg2;
  temp->sreg1 = D.27592;
  D.27593 = cfg->ip;
  temp->cil_code = D.27593;
  D.27594 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.27594;
  D.27595 = mono_alloc_ireg (cfg);
  D.27596 = (int) D.27595;
  temp->dreg = D.27596;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.27597 = ins->opcode;
  D.27598 = (int) D.27597;
  D.27599 = mono_op_imm_to_op (D.27598);
  D.27600 = (short unsigned int) D.27599;
  ins->opcode = D.27600;
  D.27597 = ins->opcode;
  if (D.27597 == 338) goto <D.27601>; else goto <D.27602>;
  <D.27601>:
  D.27603 = temp->dreg;
  ins->sreg1 = D.27603;
  goto <D.27604>;
  <D.27602>:
  D.27603 = temp->dreg;
  ins->sreg2 = D.27603;
  <D.27604>:
  D.27605 = cfg->next_vreg;
  D.27606 = bb->max_vreg;
  D.27607 = MAX_EXPR <D.27605, D.27606>;
  bb->max_vreg = D.27607;
}


mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.27608;
  int D.27609;
  unsigned int D.27610;
  unsigned int D.27611;
  guint iftmp.18;
  struct MonoInst * * D.27618;
  long unsigned int D.27619;
  long unsigned int D.27620;
  void * D.27621;
  struct MonoMethodVar * D.27622;
  long unsigned int D.27623;
  void * D.27624;
  long unsigned int D.27625;
  long unsigned int D.27626;
  void * D.27627;
  unsigned int orig_count.19;
  unsigned int D.27629;
  long unsigned int D.27630;
  long unsigned int D.27631;
  int D.27632;
  int D.27633;
  struct MonoMemPool * D.27634;
  long int D.27635;
  struct MonoInst * D.27636;
  short unsigned int D.27637;
  int D.27638;
  int D.27639;
  const unsigned char * D.27640;
  long int D.27641;
  struct MonoClass * D.27642;
  struct MonoClass * D.27643;
  unsigned char D.27644;
  long unsigned int D.27647;
  long unsigned int D.27648;
  long unsigned int D.27651;
  long unsigned int D.27652;
  int D.27659;
  long unsigned int D.27661;
  long unsigned int D.27662;
  int D.27663;
  unsigned char D.27664;
  unsigned char D.27665;
  long unsigned int D.27666;
  long unsigned int D.27667;
  struct MonoInst * * D.27668;
  long unsigned int D.27669;
  struct MonoMethodVar * D.27670;
  unsigned int num.20;
  unsigned int D.27676;
  int D.27679;
  int D.27680;
  int D.27681;
  int D.27682;
  unsigned int D.27685;
  unsigned int D.27686;
  unsigned char D.27691;
  unsigned char D.27692;
  long int D.27695;
  struct MonoInst * D.27696;
  int D.27697;
  int D.27698;
  struct MonoClass * D.27701;
  struct MonoType * D.27702;
  struct MonoType * D.27703;
  struct MonoClass * D.27704;
  struct MonoClass * D.27707;
  unsigned int D.27708;
  char * D.27711;
  struct MonoInst * D.27712;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.27608 = cfg->num_varinfo;
  num = (int) D.27608;
  type = mini_replace_type (type);
  D.27609 = num + 1;
  D.27610 = (unsigned int) D.27609;
  D.27611 = cfg->varinfo_count;
  if (D.27610 >= D.27611) goto <D.27612>; else goto <D.27613>;
  <D.27612>:
  {
    int orig_count;

    D.27611 = cfg->varinfo_count;
    orig_count = (int) D.27611;
    D.27611 = cfg->varinfo_count;
    if (D.27611 != 0) goto <D.27615>; else goto <D.27616>;
    <D.27615>:
    D.27611 = cfg->varinfo_count;
    iftmp.18 = D.27611 * 2;
    goto <D.27617>;
    <D.27616>:
    iftmp.18 = 64;
    <D.27617>:
    cfg->varinfo_count = iftmp.18;
    D.27618 = cfg->varinfo;
    D.27611 = cfg->varinfo_count;
    D.27619 = (long unsigned int) D.27611;
    D.27620 = D.27619 * 8;
    D.27621 = monoeg_realloc (D.27618, D.27620);
    cfg->varinfo = D.27621;
    D.27622 = cfg->vars;
    D.27611 = cfg->varinfo_count;
    D.27619 = (long unsigned int) D.27611;
    D.27623 = D.27619 * 80;
    D.27624 = monoeg_realloc (D.27622, D.27623);
    cfg->vars = D.27624;
    D.27622 = cfg->vars;
    D.27625 = (long unsigned int) orig_count;
    D.27626 = D.27625 * 80;
    D.27627 = D.27622 + D.27626;
    D.27611 = cfg->varinfo_count;
    orig_count.19 = (unsigned int) orig_count;
    D.27629 = D.27611 - orig_count.19;
    D.27630 = (long unsigned int) D.27629;
    D.27631 = D.27630 * 80;
    memset (D.27627, 0, D.27631);
  }
  <D.27613>:
  D.27632 = cfg->stat_allocate_var;
  D.27633 = D.27632 + 1;
  cfg->stat_allocate_var = D.27633;
  D.27634 = cfg->mempool;
  inst = mono_mempool_alloc (D.27634, 80);
  inst->data.op[1].const_val = 0;
  D.27635 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.27635;
  inst->prev = 0B;
  D.27636 = inst->prev;
  inst->next = D.27636;
  D.27637 = (short unsigned int) opcode;
  inst->opcode = D.27637;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.27638 = inst->sreg3;
  inst->sreg2 = D.27638;
  D.27639 = inst->sreg2;
  inst->sreg1 = D.27639;
  D.27640 = cfg->ip;
  inst->cil_code = D.27640;
  D.27641 = (long int) num;
  inst->data.op[0].const_val = D.27641;
  inst->data.op[1].vtype = type;
  D.27642 = mono_class_from_mono_type (type);
  inst->klass = D.27642;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.27643 = inst->klass;
  D.27644 = D.27643->exception_type;
  if (D.27644 != 0) goto <D.27645>; else goto <D.27646>;
  <D.27645>:
  mono_cfg_set_exception (cfg, 7);
  <D.27646>:
  D.27647 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.27648 = D.27647 & 128;
  if (D.27648 != 0) goto <D.27649>; else goto <D.27650>;
  <D.27649>:
  D.27651 = BIT_FIELD_REF <*type, 64, 64>;
  D.27652 = D.27651 & 1073741824;
  if (D.27652 != 0) goto <D.27653>; else goto <D.27654>;
  <D.27653>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.27655>;
  <D.27654>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.27659 = mono_type_is_struct (t);
    if (D.27659 != 0) goto <D.27660>; else goto <D.27656>;
    <D.27660>:
    D.27643 = inst->klass;
    D.27661 = BIT_FIELD_REF <*D.27643, 64, 256>;
    D.27662 = D.27661 & 134217728;
    if (D.27662 != 0) goto <D.27657>; else goto <D.27656>;
    <D.27656>:
    D.27663 = mini_type_is_reference (cfg, t);
    if (D.27663 != 0) goto <D.27657>; else goto <D.27658>;
    <D.27657>:
    D.27664 = inst->flags;
    D.27665 = D.27664 | 128;
    inst->flags = D.27665;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.27658>:
  }
  <D.27655>:
  <D.27650>:
  D.27618 = cfg->varinfo;
  D.27666 = (long unsigned int) num;
  D.27667 = D.27666 * 8;
  D.27668 = D.27618 + D.27667;
  *D.27668 = inst;
  D.27622 = cfg->vars;
  D.27666 = (long unsigned int) num;
  D.27669 = D.27666 * 80;
  D.27670 = D.27622 + D.27669;
  D.27670->range.first_use.pos.bid = 65535;
  D.27622 = cfg->vars;
  D.27666 = (long unsigned int) num;
  D.27669 = D.27666 * 80;
  D.27670 = D.27622 + D.27669;
  D.27670->reg = -1;
  D.27622 = cfg->vars;
  D.27666 = (long unsigned int) num;
  D.27669 = D.27666 * 80;
  D.27670 = D.27622 + D.27669;
  num.20 = (unsigned int) num;
  D.27670->idx = num.20;
  D.27622 = cfg->vars;
  D.27666 = (long unsigned int) num;
  D.27669 = D.27666 * 80;
  D.27670 = D.27622 + D.27669;
  D.27670->vreg = vreg;
  if (vreg != -1) goto <D.27672>; else goto <D.27673>;
  <D.27672>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.27673>:
  regpair = 0;
  if (regpair != 0) goto <D.27674>; else goto <D.27675>;
  <D.27674>:
  {
    struct MonoInst * tree;

    D.27676 = cfg->verbose_level;
    if (D.27676 > 3) goto <D.27677>; else goto <D.27678>;
    <D.27677>:
    D.27679 = inst->dreg;
    D.27679 = inst->dreg;
    D.27680 = D.27679 + 1;
    D.27679 = inst->dreg;
    D.27681 = D.27679 + 2;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.27679, D.27680, D.27681);
    <D.27678>:
    D.27682 = mono_arch_is_soft_float ();
    if (D.27682 != 0) goto <D.27683>; else goto <D.27684>;
    <D.27683>:
    D.27685 = cfg->opt;
    D.27686 = D.27685 & 2097152;
    if (D.27686 != 0) goto <D.27687>; else goto <D.27688>;
    <D.27687>:
    D.27651 = BIT_FIELD_REF <*type, 64, 64>;
    D.27652 = D.27651 & 1073741824;
    if (D.27652 == 0) goto <D.27689>; else goto <D.27690>;
    <D.27689>:
    D.27691 = type->type;
    D.27692 = D.27691 + 244;
    if (D.27692 <= 1) goto <D.27693>; else goto <D.27694>;
    <D.27693>:
    inst->flags = 4;
    <D.27694>:
    <D.27690>:
    <D.27688>:
    <D.27684>:
    D.27634 = cfg->mempool;
    tree = mono_mempool_alloc (D.27634, 80);
    tree->data.op[1].const_val = 0;
    D.27695 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27695;
    tree->prev = 0B;
    D.27696 = tree->prev;
    tree->next = D.27696;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27697 = tree->sreg3;
    tree->sreg2 = D.27697;
    D.27698 = tree->sreg2;
    tree->sreg1 = D.27698;
    D.27640 = cfg->ip;
    tree->cil_code = D.27640;
    D.27679 = inst->dreg;
    D.27680 = D.27679 + 1;
    tree->dreg = D.27680;
    D.27685 = cfg->opt;
    D.27686 = D.27685 & 2097152;
    if (D.27686 != 0) goto <D.27699>; else goto <D.27700>;
    <D.27699>:
    tree->flags = 4;
    <D.27700>:
    D.27641 = (long int) num;
    tree->data.op[0].const_val = D.27641;
    tree->type = 1;
    D.27701 = mono_defaults.int32_class;
    D.27702 = &D.27701->byval_arg;
    tree->data.op[1].vtype = D.27702;
    D.27703 = tree->data.op[1].vtype;
    D.27704 = mono_class_from_mono_type (D.27703);
    tree->klass = D.27704;
    D.27679 = inst->dreg;
    D.27680 = D.27679 + 1;
    set_vreg_to_inst (cfg, D.27680, tree);
    D.27634 = cfg->mempool;
    tree = mono_mempool_alloc (D.27634, 80);
    tree->data.op[1].const_val = 0;
    D.27695 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.27695;
    tree->prev = 0B;
    D.27696 = tree->prev;
    tree->next = D.27696;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.27697 = tree->sreg3;
    tree->sreg2 = D.27697;
    D.27698 = tree->sreg2;
    tree->sreg1 = D.27698;
    D.27640 = cfg->ip;
    tree->cil_code = D.27640;
    D.27679 = inst->dreg;
    D.27681 = D.27679 + 2;
    tree->dreg = D.27681;
    D.27685 = cfg->opt;
    D.27686 = D.27685 & 2097152;
    if (D.27686 != 0) goto <D.27705>; else goto <D.27706>;
    <D.27705>:
    tree->flags = 4;
    <D.27706>:
    D.27641 = (long int) num;
    tree->data.op[0].const_val = D.27641;
    tree->type = 1;
    D.27701 = mono_defaults.int32_class;
    D.27702 = &D.27701->byval_arg;
    tree->data.op[1].vtype = D.27702;
    D.27703 = tree->data.op[1].vtype;
    D.27707 = mono_class_from_mono_type (D.27703);
    tree->klass = D.27707;
    D.27679 = inst->dreg;
    D.27681 = D.27679 + 2;
    set_vreg_to_inst (cfg, D.27681, tree);
  }
  <D.27675>:
  D.27608 = cfg->num_varinfo;
  D.27708 = D.27608 + 1;
  cfg->num_varinfo = D.27708;
  D.27676 = cfg->verbose_level;
  if (D.27676 > 2) goto <D.27709>; else goto <D.27710>;
  <D.27709>:
  D.27711 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.27711);
  <D.27710>:
  D.27712 = inst;
  return D.27712;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27716;
  int D.27721;
  void * D.27723;
  long unsigned int D.27724;

  D.27716 = __builtin_constant_p (__len);
  if (D.27716 != 0) goto <D.27717>; else goto <D.27718>;
  <D.27717>:
  if (__len == 0) goto <D.27719>; else goto <D.27720>;
  <D.27719>:
  D.27721 = __builtin_constant_p (__ch);
  if (D.27721 == 0) goto <D.27714>; else goto <D.27722>;
  <D.27722>:
  if (__ch != 0) goto <D.27714>; else goto <D.27715>;
  <D.27714>:
  __warn_memset_zero_len ();
  D.27723 = __dest;
  return D.27723;
  <D.27715>:
  <D.27720>:
  <D.27718>:
  D.27724 = __builtin_object_size (__dest, 0);
  D.27723 = __builtin___memset_chk (__dest, __ch, __len, D.27724);
  return D.27723;
}


mono_arch_is_soft_float ()
{
  gboolean D.27726;

  D.27726 = 0;
  return D.27726;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int vreg.21;
  unsigned int D.27729;
  guint32 iftmp.22;
  struct MonoMemPool * D.27736;
  unsigned int D.27737;
  void * D.27738;
  struct MonoInst * * D.27741;
  long unsigned int D.27742;
  long unsigned int D.27743;
  long unsigned int D.27744;
  long unsigned int D.27745;
  struct MonoInst * * D.27746;

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

    tmp = cfg->vreg_to_inst;
    D.27729 = cfg->vreg_to_inst_len;
    size = (int) D.27729;
    goto <D.25348>;
    <D.25347>:
    D.27729 = cfg->vreg_to_inst_len;
    if (D.27729 != 0) goto <D.27733>; else goto <D.27734>;
    <D.27733>:
    D.27729 = cfg->vreg_to_inst_len;
    iftmp.22 = D.27729 * 2;
    goto <D.27735>;
    <D.27734>:
    iftmp.22 = 32;
    <D.27735>:
    cfg->vreg_to_inst_len = iftmp.22;
    <D.25348>:
    vreg.21 = (unsigned int) vreg;
    D.27729 = cfg->vreg_to_inst_len;
    if (vreg.21 >= D.27729) goto <D.25347>; else goto <D.25349>;
    <D.25349>:
    D.27736 = cfg->mempool;
    D.27729 = cfg->vreg_to_inst_len;
    D.27737 = D.27729 * 8;
    D.27738 = mono_mempool_alloc0 (D.27736, D.27737);
    cfg->vreg_to_inst = D.27738;
    if (size != 0) goto <D.27739>; else goto <D.27740>;
    <D.27739>:
    D.27741 = cfg->vreg_to_inst;
    D.27742 = (long unsigned int) size;
    D.27743 = D.27742 * 8;
    memcpy (D.27741, tmp, D.27743);
    <D.27740>:
  }
  <D.27731>:
  D.27741 = cfg->vreg_to_inst;
  D.27744 = (long unsigned int) vreg;
  D.27745 = D.27744 * 8;
  D.27746 = D.27741 + D.27745;
  *D.27746 = inst;
}


mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  long unsigned int D.27750;
  long unsigned int D.27751;
  struct MonoType * D.27753;
  unsigned char D.27754;
  struct MonoType * D.27756;
  unsigned char D.27757;
  unsigned int D.27758;
  int D.27761;
  unsigned char D.27764;
  unsigned char D.27765;
  unsigned int D.27767;
  unsigned int D.27768;
  struct MonoInst * D.27769;
  int dreg;

  type = mini_replace_type (type);
  D.27750 = BIT_FIELD_REF <*type, 64, 64>;
  D.27751 = D.27750 & 1073741824;
  if (D.27751 == 0) goto <D.27752>; else goto <D.27747>;
  <D.27752>:
  D.27753 = mono_type_get_underlying_type (type);
  D.27754 = D.27753->type;
  if (D.27754 == 10) goto <D.27748>; else goto <D.27755>;
  <D.27755>:
  D.27756 = mono_type_get_underlying_type (type);
  D.27757 = D.27756->type;
  if (D.27757 == 11) goto <D.27748>; else goto <D.27747>;
  <D.27748>:
  D.27758 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.27758;
  goto <D.27749>;
  <D.27747>:
  D.27761 = mono_arch_is_soft_float ();
  if (D.27761 != 0) goto <D.27762>; else goto <D.27759>;
  <D.27762>:
  D.27750 = BIT_FIELD_REF <*type, 64, 64>;
  D.27751 = D.27750 & 1073741824;
  if (D.27751 == 0) goto <D.27763>; else goto <D.27759>;
  <D.27763>:
  D.27764 = type->type;
  D.27765 = D.27764 + 244;
  if (D.27765 <= 1) goto <D.27766>; else goto <D.27759>;
  <D.27766>:
  D.27767 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.27767;
  goto <D.27760>;
  <D.27759>:
  D.27768 = mono_alloc_preg (cfg);
  dreg = (int) D.27768;
  <D.27760>:
  <D.27749>:
  D.27769 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.27769;
}


mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.27771;
  long unsigned int var_index.23;
  long unsigned int D.27773;
  struct MonoInst * * D.27774;
  struct MonoInst * D.27775;
  struct MonoInst * D.27776;
  struct MonoType * D.27777;
  unsigned int D.27778;
  short unsigned int D.27779;
  struct MonoClass * D.27780;

  memset (dest, 0, 80);
  D.27771 = cfg->varinfo;
  var_index.23 = (long unsigned int) var_index;
  D.27773 = var_index.23 * 8;
  D.27774 = D.27771 + D.27773;
  D.27775 = *D.27774;
  dest->data.op[0].src = D.27775;
  D.27776 = dest->data.op[0].src;
  D.27777 = D.27776->data.op[1].vtype;
  D.27778 = mini_type_to_ldind (cfg, D.27777);
  D.27779 = (short unsigned int) D.27778;
  dest->opcode = D.27779;
  D.27776 = dest->data.op[0].src;
  D.27777 = D.27776->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.27777, dest);
  D.27776 = dest->data.op[0].src;
  D.27780 = D.27776->klass;
  dest->klass = D.27780;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.27781;
  long unsigned int D.27784;
  long unsigned int D.27785;
  unsigned char D.27790;
  int D.27792;
  guint D.27795;

  D.27781 = cfg->generic_sharing_context;
  if (D.27781 != 0B) goto <D.27782>; else goto <D.27783>;
  <D.27782>:
  D.27784 = BIT_FIELD_REF <*type, 64, 64>;
  D.27785 = D.27784 & 1073741824;
  if (D.27785 == 0) goto <D.27786>; else goto <D.27787>;
  <D.27786>:
  D.27790 = type->type;
  if (D.27790 == 19) goto <D.27788>; else goto <D.27791>;
  <D.27791>:
  D.27790 = type->type;
  if (D.27790 == 30) goto <D.27788>; else goto <D.27789>;
  <D.27788>:
  D.27792 = mini_type_var_is_vt (cfg, type);
  if (D.27792 != 0) goto <D.27793>; else goto <D.27794>;
  <D.27793>:
  D.27795 = 113;
  return D.27795;
  <D.27794>:
  D.27795 = 80;
  return D.27795;
  <D.27789>:
  <D.27787>:
  <D.27783>:
  D.27795 = mono_type_to_ldind (type);
  return D.27795;
}


mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.24;
  unsigned int D.27798;
  guint32 iftmp.25;
  struct MonoMemPool * D.27805;
  unsigned int D.27806;
  void * D.27807;
  gboolean * D.27810;
  long unsigned int D.27811;
  long unsigned int D.27812;
  long unsigned int D.27813;
  long unsigned int D.27814;
  gboolean * D.27815;

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

    tmp = cfg->vreg_is_ref;
    D.27798 = cfg->vreg_is_ref_len;
    size = (int) D.27798;
    goto <D.25380>;
    <D.25379>:
    D.27798 = cfg->vreg_is_ref_len;
    if (D.27798 != 0) goto <D.27802>; else goto <D.27803>;
    <D.27802>:
    D.27798 = cfg->vreg_is_ref_len;
    iftmp.25 = D.27798 * 2;
    goto <D.27804>;
    <D.27803>:
    iftmp.25 = 32;
    <D.27804>:
    cfg->vreg_is_ref_len = iftmp.25;
    <D.25380>:
    vreg.24 = (unsigned int) vreg;
    D.27798 = cfg->vreg_is_ref_len;
    if (vreg.24 >= D.27798) goto <D.25379>; else goto <D.25381>;
    <D.25381>:
    D.27805 = cfg->mempool;
    D.27798 = cfg->vreg_is_ref_len;
    D.27806 = D.27798 * 4;
    D.27807 = mono_mempool_alloc0 (D.27805, D.27806);
    cfg->vreg_is_ref = D.27807;
    if (size != 0) goto <D.27808>; else goto <D.27809>;
    <D.27808>:
    D.27810 = cfg->vreg_is_ref;
    D.27811 = (long unsigned int) size;
    D.27812 = D.27811 * 4;
    memcpy (D.27810, tmp, D.27812);
    <D.27809>:
  }
  <D.27800>:
  D.27810 = cfg->vreg_is_ref;
  D.27813 = (long unsigned int) vreg;
  D.27814 = D.27813 * 4;
  D.27815 = D.27810 + D.27814;
  *D.27815 = 1;
}


mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.26;
  unsigned int D.27817;
  guint32 iftmp.27;
  struct MonoMemPool * D.27824;
  unsigned int D.27825;
  void * D.27826;
  gboolean * D.27829;
  long unsigned int D.27830;
  long unsigned int D.27831;
  long unsigned int D.27832;
  long unsigned int D.27833;
  gboolean * D.27834;

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

    tmp = cfg->vreg_is_mp;
    D.27817 = cfg->vreg_is_mp_len;
    size = (int) D.27817;
    goto <D.25389>;
    <D.25388>:
    D.27817 = cfg->vreg_is_mp_len;
    if (D.27817 != 0) goto <D.27821>; else goto <D.27822>;
    <D.27821>:
    D.27817 = cfg->vreg_is_mp_len;
    iftmp.27 = D.27817 * 2;
    goto <D.27823>;
    <D.27822>:
    iftmp.27 = 32;
    <D.27823>:
    cfg->vreg_is_mp_len = iftmp.27;
    <D.25389>:
    vreg.26 = (unsigned int) vreg;
    D.27817 = cfg->vreg_is_mp_len;
    if (vreg.26 >= D.27817) goto <D.25388>; else goto <D.25390>;
    <D.25390>:
    D.27824 = cfg->mempool;
    D.27817 = cfg->vreg_is_mp_len;
    D.27825 = D.27817 * 4;
    D.27826 = mono_mempool_alloc0 (D.27824, D.27825);
    cfg->vreg_is_mp = D.27826;
    if (size != 0) goto <D.27827>; else goto <D.27828>;
    <D.27827>:
    D.27829 = cfg->vreg_is_mp;
    D.27830 = (long unsigned int) size;
    D.27831 = D.27830 * 4;
    memcpy (D.27829, tmp, D.27831);
    <D.27828>:
  }
  <D.27819>:
  D.27829 = cfg->vreg_is_mp;
  D.27832 = (long unsigned int) vreg;
  D.27833 = D.27832 * 4;
  D.27834 = D.27829 + D.27833;
  *D.27834 = 1;
}


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

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


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.27837;
  int D.27838;
  struct MonoType * D.27839;
  struct MonoClass * D.27840;
  struct MonoClass * D.27841;
  struct MonoClass * D.27842;
  struct MonoClass * D.27843;
  struct MonoClass * D.27844;
  struct MonoClass * D.27847;
  long unsigned int D.27850;
  long unsigned int D.27851;

  D.27837 = ins->type;
  D.27838 = (int) D.27837;
  switch (D.27838) <default: <D.25401>, case 1: <D.25394>, case 2: <D.25395>, case 3: <D.25396>, case 4: <D.25397>, case 5: <D.25398>, case 6: <D.25399>, case 7: <D.25400>>
  <D.25394>:
  D.27840 = mono_defaults.int32_class;
  D.27839 = &D.27840->byval_arg;
  return D.27839;
  <D.25395>:
  D.27841 = mono_defaults.int64_class;
  D.27839 = &D.27841->byval_arg;
  return D.27839;
  <D.25396>:
  D.27842 = mono_defaults.int_class;
  D.27839 = &D.27842->byval_arg;
  return D.27839;
  <D.25397>:
  D.27843 = mono_defaults.double_class;
  D.27839 = &D.27843->byval_arg;
  return D.27839;
  <D.25398>:
  D.27844 = ins->klass;
  if (D.27844 != 0B) goto <D.27845>; else goto <D.27846>;
  <D.27845>:
  D.27844 = ins->klass;
  D.27839 = &D.27844->this_arg;
  return D.27839;
  <D.27846>:
  D.27847 = mono_defaults.object_class;
  D.27839 = &D.27847->this_arg;
  return D.27839;
  <D.25399>:
  D.27844 = ins->klass;
  if (D.27844 != 0B) goto <D.27848>; else goto <D.27849>;
  <D.27848>:
  D.27844 = ins->klass;
  D.27850 = BIT_FIELD_REF <*D.27844, 64, 256>;
  D.27851 = D.27850 & 8;
  if (D.27851 == 0) goto <D.27852>; else goto <D.27853>;
  <D.27852>:
  D.27844 = ins->klass;
  D.27839 = &D.27844->byval_arg;
  return D.27839;
  <D.27853>:
  <D.27849>:
  D.27847 = mono_defaults.object_class;
  D.27839 = &D.27847->byval_arg;
  return D.27839;
  <D.25400>:
  D.27844 = ins->klass;
  D.27839 = &D.27844->byval_arg;
  return D.27839;
  <D.25401>:
  D.27837 = ins->type;
  D.27838 = (int) D.27837;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.27838);
  <D.25402>:
  goto <D.25402>;
  D.27839 = 0B;
  return D.27839;
}


mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.27855;
  struct MonoInst * D.27858;
  short unsigned int D.27862;
  int D.27863;
  short unsigned int D.27867;
  short unsigned int D.27869;
  short unsigned int D.27871;
  struct MonoInst * D.27874;
  short unsigned int D.27877;
  unsigned int opcode.28;
  unsigned int D.27882;
  struct MonoInst * D.27889;
  short unsigned int D.27890;
  int opcode;

  D.27855 = bb->code;
  if (D.27855 == 0B) goto <D.27856>; else goto <D.27857>;
  <D.27856>:
  D.27858 = bb->last_ins;
  if (D.27858 != 0B) goto <D.27859>; else goto <D.27860>;
  <D.27859>:
  D.27858 = bb->last_ins;
  D.27858->next = inst;
  D.27858 = bb->last_ins;
  inst->prev = D.27858;
  bb->last_ins = inst;
  goto <D.27861>;
  <D.27860>:
  bb->last_ins = inst;
  D.27858 = bb->last_ins;
  bb->code = D.27858;
  <D.27861>:
  return;
  <D.27857>:
  D.27858 = bb->last_ins;
  D.27862 = D.27858->opcode;
  D.27863 = (int) D.27862;
  switch (D.27863) <default: <D.25425>, case 59: <D.25413>, case 60: <D.25414>, case 61: <D.25415>, case 62: <D.25416>, case 63: <D.25417>, case 64: <D.25418>, case 65: <D.25419>, case 66: <D.25420>, case 67: <D.25421>, case 68: <D.25422>, case 370: <D.25423>, case 442: <D.25411>, case 759: <D.25412>>
  <D.25411>:
  <D.25412>:
  <D.25413>:
  <D.25414>:
  <D.25415>:
  <D.25416>:
  <D.25417>:
  <D.25418>:
  <D.25419>:
  <D.25420>:
  <D.25421>:
  <D.25422>:
  <D.25423>:
  D.27858 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27858, inst);
  goto <D.25424>;
  <D.25425>:
  D.27858 = bb->last_ins;
  D.27862 = D.27858->opcode;
  D.27867 = D.27862 + 64985;
  if (D.27867 <= 9) goto <D.27864>; else goto <D.27868>;
  <D.27868>:
  D.27858 = bb->last_ins;
  D.27862 = D.27858->opcode;
  D.27869 = D.27862 + 64878;
  if (D.27869 <= 9) goto <D.27864>; else goto <D.27870>;
  <D.27870>:
  D.27858 = bb->last_ins;
  D.27862 = D.27858->opcode;
  D.27871 = D.27862 + 64888;
  if (D.27871 <= 9) goto <D.27864>; else goto <D.27865>;
  <D.27864>:
  D.27855 = bb->code;
  D.27858 = bb->last_ins;
  if (D.27855 == D.27858) goto <D.27872>; else goto <D.27873>;
  <D.27872>:
  D.27858 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27858, inst);
  return;
  <D.27873>:
  D.27855 = bb->code;
  D.27874 = D.27855->next;
  D.27858 = bb->last_ins;
  if (D.27874 == D.27858) goto <D.27875>; else goto <D.27876>;
  <D.27875>:
  D.27855 = bb->code;
  D.27877 = D.27855->opcode;
  opcode = (int) D.27877;
  opcode.28 = (unsigned int) opcode;
  D.27882 = opcode.28 + 4294966974;
  if (D.27882 <= 1) goto <D.27878>; else goto <D.27883>;
  <D.27883>:
  if (opcode == 326) goto <D.27878>; else goto <D.27884>;
  <D.27884>:
  if (opcode == 327) goto <D.27878>; else goto <D.27885>;
  <D.27885>:
  if (opcode == 324) goto <D.27878>; else goto <D.27886>;
  <D.27886>:
  if (opcode == 325) goto <D.27878>; else goto <D.27887>;
  <D.27887>:
  if (opcode == 328) goto <D.27878>; else goto <D.27879>;
  <D.27878>:
  D.27855 = bb->code;
  mono_bblock_insert_before_ins (bb, D.27855, inst);
  goto <D.27880>;
  <D.27879>:
  D.27858 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27858, inst);
  <D.27880>:
  goto <D.27888>;
  <D.27876>:
  D.27858 = bb->last_ins;
  D.27889 = D.27858->prev;
  D.27890 = D.27889->opcode;
  opcode = (int) D.27890;
  opcode.28 = (unsigned int) opcode;
  D.27882 = opcode.28 + 4294966974;
  if (D.27882 <= 1) goto <D.27891>; else goto <D.27894>;
  <D.27894>:
  if (opcode == 326) goto <D.27891>; else goto <D.27895>;
  <D.27895>:
  if (opcode == 327) goto <D.27891>; else goto <D.27896>;
  <D.27896>:
  if (opcode == 324) goto <D.27891>; else goto <D.27897>;
  <D.27897>:
  if (opcode == 325) goto <D.27891>; else goto <D.27898>;
  <D.27898>:
  if (opcode == 328) goto <D.27891>; else goto <D.27892>;
  <D.27891>:
  D.27858 = bb->last_ins;
  D.27889 = D.27858->prev;
  mono_bblock_insert_before_ins (bb, D.27889, inst);
  goto <D.27893>;
  <D.27892>:
  D.27858 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.27858, inst);
  <D.27893>:
  <D.27888>:
  goto <D.27866>;
  <D.27865>:
  D.27858 = bb->last_ins;
  if (D.27858 != 0B) goto <D.27899>; else goto <D.27900>;
  <D.27899>:
  D.27858 = bb->last_ins;
  D.27858->next = inst;
  D.27858 = bb->last_ins;
  inst->prev = D.27858;
  bb->last_ins = inst;
  goto <D.27901>;
  <D.27900>:
  bb->last_ins = inst;
  D.27858 = bb->last_ins;
  bb->code = D.27858;
  <D.27901>:
  <D.27866>:
  goto <D.25424>;
  <D.25424>:
}


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

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


mono_get_array_new_va_icall (int rank)
{
  _Bool D.27907;
  long int D.27908;
  long int D.27909;
  struct GHashTable * jit_icall_name_hash.29;
  _Bool D.27917;
  long int D.27918;
  long int D.27919;
  struct MonoJitICallInfo * D.27922;
  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.27905>; else goto <D.27906>;
        <D.27905>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27906>:
        D.27907 = ret != 0;
        D.27908 = (long int) D.27907;
        D.27909 = __builtin_expect (D.27908, 0);
        if (D.27909 != 0) goto <D.27910>; else goto <D.27911>;
        <D.27910>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.27911>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.27912>; else goto <D.27913>;
      <D.27912>:
      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.27913>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.27915>; else goto <D.27916>;
        <D.27915>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27916>:
        D.27917 = ret != 0;
        D.27918 = (long int) D.27917;
        D.27919 = __builtin_expect (D.27918, 0);
        if (D.27919 != 0) goto <D.27920>; else goto <D.27921>;
        <D.27920>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.27921>:
      }
      D.27922 = info;
      return D.27922;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


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

  D.27926 = __builtin_object_size (__s, 1);
  D.27925 = __builtin___sprintf_chk (__s, 1, D.27926, __fmt, __builtin_va_arg_pack ());
  return D.27925;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.27930;
  long int D.27931;
  long int D.27932;
  struct GHashTable * sighash.30;
  struct GHashTable * sighash.31;
  long int D.27940;
  const void * D.27941;
  _Bool D.27946;
  long int D.27947;
  long int D.27948;
  struct MonoMethodSignature * D.27951;
  struct MonoImage * D.27952;
  int D.27953;
  unsigned int D.27954;
  struct MonoClass * D.27957;
  struct MonoType * D.27958;
  int D.27959;
  struct MonoClass * D.27960;
  struct MonoType * D.27961;
  void * D.27962;
  _Bool D.27965;
  long int D.27966;
  long int D.27967;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27928>; else goto <D.27929>;
    <D.27928>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27929>:
    D.27930 = ret != 0;
    D.27931 = (long int) D.27930;
    D.27932 = __builtin_expect (D.27931, 0);
    if (D.27932 != 0) goto <D.27933>; else goto <D.27934>;
    <D.27933>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.27934>:
  }
  sighash.30 = sighash;
  if (sighash.30 == 0B) goto <D.27936>; else goto <D.27937>;
  <D.27936>:
  sighash.31 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.31;
  goto <D.27939>;
  <D.27937>:
  sighash.30 = sighash;
  D.27940 = (long int) arity;
  D.27941 = (const void *) D.27940;
  res = monoeg_g_hash_table_lookup (sighash.30, D.27941);
  if (res != 0B) goto <D.27942>; else goto <D.27943>;
  <D.27942>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27944>; else goto <D.27945>;
    <D.27944>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27945>:
    D.27946 = ret != 0;
    D.27947 = (long int) D.27946;
    D.27948 = __builtin_expect (D.27947, 0);
    if (D.27948 != 0) goto <D.27949>; else goto <D.27950>;
    <D.27949>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.27950>:
  }
  D.27951 = res;
  return D.27951;
  <D.27943>:
  <D.27939>:
  D.27952 = mono_defaults.corlib;
  D.27953 = arity + 1;
  D.27954 = (unsigned int) D.27953;
  res = mono_metadata_signature_alloc (D.27952, D.27954);
  res->pinvoke = 1;
  if (0 != 0) goto <D.27955>; else goto <D.27956>;
  <D.27955>:
  res->call_convention = 5;
  <D.27956>:
  D.27957 = mono_defaults.int_class;
  D.27958 = &D.27957->byval_arg;
  res->params[0] = D.27958;
  i = 0;
  goto <D.25443>;
  <D.25442>:
  D.27959 = i + 1;
  D.27957 = mono_defaults.int_class;
  D.27958 = &D.27957->byval_arg;
  res->params[D.27959] = D.27958;
  i = i + 1;
  <D.25443>:
  if (i < arity) goto <D.25442>; else goto <D.25444>;
  <D.25444>:
  D.27960 = mono_defaults.object_class;
  D.27961 = &D.27960->byval_arg;
  res->ret = D.27961;
  sighash.30 = sighash;
  D.27940 = (long int) arity;
  D.27962 = (void *) D.27940;
  monoeg_g_hash_table_insert_replace (sighash.30, D.27962, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.27963>; else goto <D.27964>;
    <D.27963>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27964>:
    D.27965 = ret != 0;
    D.27966 = (long int) D.27965;
    D.27967 = __builtin_expect (D.27966, 0);
    if (D.27967 != 0) goto <D.27968>; else goto <D.27969>;
    <D.27968>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.27969>:
  }
  D.27951 = res;
  return D.27951;
}


mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.27971;
  struct MonoClass * D.27972;
  gboolean D.27975;

  D.27971 = klass->parent;
  D.27972 = mono_defaults.array_class;
  if (D.27971 == D.27972) goto <D.27973>; else goto <D.27974>;
  <D.27973>:
  D.27975 = 1;
  return D.27975;
  <D.27974>:
  D.27975 = 0;
  return D.27975;
}


mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.27977;
  struct MonoImage * D.27978;
  long unsigned int D.27979;
  long unsigned int D.27980;
  gboolean D.27985;
  unsigned char D.27988;
  struct MonoImage * D.27990;
  struct MonoImage * D.27991;
  int D.27992;
  struct MonoAssembly * assembly;

  D.27977 = method->klass;
  D.27978 = D.27977->image;
  assembly = D.27978->assembly;
  D.27979 = BIT_FIELD_REF <*method, 64, 256>;
  D.27980 = D.27979 & 124;
  if (D.27980 != 0) goto <D.27981>; else goto <D.27982>;
  <D.27981>:
  D.27979 = BIT_FIELD_REF <*method, 64, 256>;
  D.27980 = D.27979 & 124;
  if (D.27980 != 68) goto <D.27983>; else goto <D.27984>;
  <D.27983>:
  D.27985 = 0;
  return D.27985;
  <D.27984>:
  <D.27982>:
  D.27988 = assembly->in_gac;
  if (D.27988 != 0) goto <D.27986>; else goto <D.27989>;
  <D.27989>:
  D.27990 = assembly->image;
  D.27991 = mono_defaults.corlib;
  if (D.27990 == D.27991) goto <D.27986>; else goto <D.27987>;
  <D.27986>:
  D.27985 = 0;
  return D.27985;
  <D.27987>:
  D.27992 = mono_is_security_manager_active ();
  if (D.27992 != 0) goto <D.27993>; else goto <D.27994>;
  <D.27993>:
  D.27985 = 0;
  return D.27985;
  <D.27994>:
  D.27985 = mono_assembly_has_skip_verification (assembly);
  return D.27985;
}


mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.27996;
  struct MonoImage * D.27997;
  struct MonoAssembly * D.27998;
  unsigned char D.27999;
  long unsigned int D.28000;
  long unsigned int D.28001;
  gboolean D.28002;
  int iftmp.32;
  int D.28007;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.27996 = method->klass;
  D.27997 = D.27996->image;
  D.27998 = D.27997->assembly;
  D.27999 = D.27998->corlib_internal;
  dont_verify = (gboolean) D.27999;
  goto <D.25487>;
  <D.25486>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.25487>:
  D.28000 = BIT_FIELD_REF <*method_definition, 64, 256>;
  D.28001 = D.28000 & 4096;
  if (D.28001 != 0) goto <D.25486>; else goto <D.25488>;
  <D.25488>:
  if (dont_verify == 0) goto <D.28006>; else goto <D.28004>;
  <D.28006>:
  D.28007 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.28007 != 0) goto <D.28008>; else goto <D.28004>;
  <D.28008>:
  iftmp.32 = 1;
  goto <D.28005>;
  <D.28004>:
  iftmp.32 = 0;
  <D.28005>:
  D.28002 = iftmp.32;
  return D.28002;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  long unsigned int D.28010;
  long unsigned int D.28011;
  gboolean D.28014;
  int D.28015;
  int iftmp.33;
  int D.28022;
  struct MonoDomain * D.28024;
  int D.28025;
  <unnamed-unsigned:1> D.28026;
  int D.28027;
  unsigned char D.28032;
  unsigned int D.28033;
  <unnamed type> D.28039;
  signed char D.28044;
  unsigned int D.28045;
  char * D.28046;
  gchar * D.28047;
  gchar * D.28056;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.28010 = BIT_FIELD_REF <*method, 64, 256>;
  D.28011 = D.28010 & 16384;
  if (D.28011 != 0) goto <D.28012>; else goto <D.28013>;
  <D.28012>:
  D.28014 = 0;
  return D.28014;
  <D.28013>:
  D.28015 = mono_verifier_is_enabled_for_method (method);
  if (D.28015 == 0) goto <D.28016>; else goto <D.28017>;
  <D.28016>:
  D.28014 = 0;
  return D.28014;
  <D.28017>:
  D.28022 = mono_verifier_is_method_full_trust (method);
  if (D.28022 != 0) goto <D.28019>; else goto <D.28023>;
  <D.28023>:
  D.28024 = cfg->domain;
  D.28025 = mini_assembly_can_skip_verification (D.28024, method);
  if (D.28025 != 0) goto <D.28019>; else goto <D.28020>;
  <D.28019>:
  iftmp.33 = 1;
  goto <D.28021>;
  <D.28020>:
  iftmp.33 = 0;
  <D.28021>:
  is_fulltrust = iftmp.33;
  D.28026 = cfg->skip_visibility;
  D.28027 = (int) D.28026;
  res = mono_method_verify_with_current_settings (method, D.28027, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.28028>; else goto <D.28029>;
  <D.28028>:
  if (fail_compile != 0) goto <D.28030>; else goto <D.28031>;
  <D.28030>:
  D.28032 = error->exception_type;
  D.28033 = (unsigned int) D.28032;
  cfg->exception_type = D.28033;
  goto <D.28034>;
  <D.28031>:
  mono_loader_clear_error ();
  <D.28034>:
  if (res != 0B) goto <D.28035>; else goto <D.28036>;
  <D.28035>:
  mono_free_verify_list (res);
  <D.28036>:
  D.28014 = 1;
  return D.28014;
  <D.28029>:
  if (res != 0B) goto <D.28037>; else goto <D.28038>;
  <D.28037>:
  tmp = res;
  goto <D.25476>;
  <D.25475>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.28039 = info->info.status;
    if (D.28039 == 1) goto <D.28040>; else goto <D.28041>;
    <D.28040>:
    if (fail_compile != 0) goto <D.28042>; else goto <D.28043>;
    <D.28042>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.28044 = info->exception_type;
      D.28045 = (unsigned int) D.28044;
      cfg->exception_type = D.28045;
      D.28046 = info->info.message;
      D.28047 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.28046);
      cfg->exception_message = D.28047;
      monoeg_g_free (method_name);
    }
    <D.28043>:
    mono_free_verify_list (res);
    D.28014 = 1;
    return D.28014;
    <D.28041>:
    D.28039 = info->info.status;
    if (D.28039 == 8) goto <D.28050>; else goto <D.28051>;
    <D.28050>:
    if (is_fulltrust == 0) goto <D.28048>; else goto <D.28052>;
    <D.28052>:
    D.28044 = info->exception_type;
    if (D.28044 == 9) goto <D.28048>; else goto <D.28053>;
    <D.28053>:
    D.28044 = info->exception_type;
    if (D.28044 == 10) goto <D.28048>; else goto <D.28049>;
    <D.28048>:
    if (fail_compile != 0) goto <D.28054>; else goto <D.28055>;
    <D.28054>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.28044 = info->exception_type;
      D.28045 = (unsigned int) D.28044;
      cfg->exception_type = D.28045;
      D.28046 = info->info.message;
      D.28056 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.28046);
      cfg->exception_message = D.28056;
      monoeg_g_free (method_name);
    }
    <D.28055>:
    mono_free_verify_list (res);
    D.28014 = 1;
    return D.28014;
    <D.28049>:
    <D.28051>:
  }
  tmp = tmp->next;
  <D.25476>:
  if (tmp != 0B) goto <D.25475>; else goto <D.25477>;
  <D.25477>:
  mono_free_verify_list (res);
  <D.28038>:
  method->verification_success = 1;
  D.28014 = 0;
  return D.28014;
}


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

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


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.28060;
  const void * D.28063;
  const void * D.28064;
  union mono_mutex_t * D.28067;
  _Bool D.28070;
  long int D.28071;
  long int D.28072;
  _Bool D.28079;
  long int D.28080;
  long int D.28081;
  const char * D.28084;
  struct MonoMethodSignature * D.28085;
  const void * D.28086;
  int check_for_pending_exc.34;
  void * D.28091;
  _Bool D.28094;
  long int D.28095;
  long int D.28096;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.28060 = callinfo->wrapper;
  if (D.28060 != 0B) goto <D.28061>; else goto <D.28062>;
  <D.28061>:
  D.28063 = callinfo->wrapper;
  return D.28063;
  <D.28062>:
  D.28064 = callinfo->trampoline;
  if (D.28064 != 0B) goto <D.28065>; else goto <D.28066>;
  <D.28065>:
  D.28063 = callinfo->trampoline;
  return D.28063;
  <D.28066>:
  mono_loader_lock ();
  {
    int ret;

    D.28067 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28067);
    if (ret != 0) goto <D.28068>; else goto <D.28069>;
    <D.28068>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28069>:
    D.28070 = ret != 0;
    D.28071 = (long int) D.28070;
    D.28072 = __builtin_expect (D.28071, 0);
    if (D.28072 != 0) goto <D.28073>; else goto <D.28074>;
    <D.28073>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1697, "ret == 0");
    <D.28074>:
  }
  D.28064 = callinfo->trampoline;
  if (D.28064 != 0B) goto <D.28075>; else goto <D.28076>;
  <D.28075>:
  {
    int ret;

    D.28067 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28067);
    if (ret != 0) goto <D.28077>; else goto <D.28078>;
    <D.28077>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28078>:
    D.28079 = ret != 0;
    D.28080 = (long int) D.28079;
    D.28081 = __builtin_expect (D.28080, 0);
    if (D.28081 != 0) goto <D.28082>; else goto <D.28083>;
    <D.28082>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.28083>:
  }
  mono_loader_unlock ();
  D.28063 = callinfo->trampoline;
  return D.28063;
  <D.28076>:
  D.28084 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.28084);
  D.28085 = callinfo->sig;
  D.28086 = callinfo->func;
  check_for_pending_exc.34 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.28085, name, D.28086, check_for_pending_exc.34);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.28088>; else goto <D.28089>;
  <D.28088>:
  trampoline = mono_compile_method (wrapper);
  goto <D.28090>;
  <D.28089>:
  D.28091 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.28091);
  <D.28090>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.28067 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28067);
    if (ret != 0) goto <D.28092>; else goto <D.28093>;
    <D.28092>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28093>:
    D.28094 = ret != 0;
    D.28095 = (long int) D.28094;
    D.28096 = __builtin_expect (D.28095, 0);
    if (D.28096 != 0) goto <D.28097>; else goto <D.28098>;
    <D.28097>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.28098>:
  }
  mono_loader_unlock ();
  D.28063 = callinfo->trampoline;
  return D.28063;
}


mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.28100;
  struct MonoMethodVar * D.28103;
  struct MonoLiveInterval * D.28104;
  gint32 * D.28107;
  struct MonoMemPool * D.28108;
  unsigned int D.28109;
  long unsigned int D.28110;
  long unsigned int D.28111;
  gint32 * D.28112;
  unsigned int i.35;
  unsigned int D.28114;
  struct MonoInst * * D.28115;
  long unsigned int D.28116;
  struct MonoInst * * D.28117;
  long unsigned int D.28118;
  unsigned char D.28121;
  int D.28122;
  int D.28123;
  short unsigned int D.28125;
  unsigned int D.28127;
  long unsigned int D.28128;
  long unsigned int D.28129;
  struct MonoInst * * D.28130;
  struct MonoType * D.28131;
  int D.28132;
  int D.28135;
  int D.28140;
  int D.28142;
  unsigned char D.28144;
  struct MonoClass * D.28146;
  int ialign.36;
  unsigned int ialign.37;
  struct MonoClass * D.28149;
  unsigned char D.28150;
  long unsigned int D.28155;
  long unsigned int D.28156;
  long unsigned int D.28159;
  long unsigned int D.28160;
  int D.28164;
  int D.28165;
  long unsigned int D.28168;
  long unsigned int D.28169;
  struct MonoClass * D.28172;
  long unsigned int D.28173;
  struct StackSlotInfo * D.28174;
  struct MonoClass * D.28175;
  _Bool D.28180;
  long int D.28181;
  long int D.28182;
  long unsigned int D.28185;
  long unsigned int D.28186;
  struct StackSlotInfo * D.28187;
  long unsigned int D.28188;
  long unsigned int D.28191;
  unsigned int D.28196;
  unsigned int D.28197;
  struct GList * D.28200;
  unsigned int D.28201;
  unsigned int D.28202;
  struct GList * D.28204;
  struct GSList * D.28205;
  unsigned int D.28206;
  long unsigned int D.28207;
  long unsigned int D.28208;
  gint32 * D.28209;
  int D.28210;
  long int D.28211;
  void * D.28212;
  struct GSList * D.28213;
  int D.28214;
  void * D.28219;
  long int D.28220;
  struct GSList * D.28221;
  struct GList * D.28222;
  int count.38;
  int count.39;
  int D.28225;
  int D.28232;
  unsigned int align.40;
  unsigned int align.41;
  guint32 iftmp.42;
  struct MonoClass * D.28238;
  int D.28239;
  unsigned int D.28240;
  struct MonoClass * D.28243;
  int D.28244;
  unsigned int size.43;
  unsigned int D.28247;
  unsigned int D.28248;
  unsigned int D.28249;
  unsigned int D.28250;
  unsigned int offset.44;
  unsigned int D.28254;
  unsigned int D.28255;
  unsigned int D.28256;
  unsigned int D.28258;
  unsigned int D.28259;
  long unsigned int D.28260;
  gint32 * D.28261;
  struct StackSlotInfo * D.28262;
  struct GList * D.28263;
  struct GList * D.28266;
  int D.28269;
  int D.28270;
  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.28100 = cfg->num_varinfo;
      if (D.28100 != 0) goto <D.28101>; else goto <D.28102>;
      <D.28101>:
      D.28103 = cfg->vars;
      D.28104 = D.28103->interval;
      if (D.28104 != 0B) goto <D.28105>; else goto <D.28106>;
      <D.28105>:
      D.28107 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.28107;
      <D.28106>:
      <D.28102>:
      D.28108 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.28108, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.28108 = cfg->mempool;
      D.28100 = cfg->num_varinfo;
      D.28109 = D.28100 * 4;
      offsets = mono_mempool_alloc (D.28108, D.28109);
      i = 0;
      goto <D.25622>;
      <D.25621>:
      D.28110 = (long unsigned int) i;
      D.28111 = D.28110 * 4;
      D.28112 = offsets + D.28111;
      *D.28112 = -1;
      i = i + 1;
      <D.25622>:
      i.35 = (unsigned int) i;
      D.28100 = cfg->num_varinfo;
      if (i.35 < D.28100) goto <D.25621>; else goto <D.25623>;
      <D.25623>:
      D.28114 = cfg->locals_start;
      i = (int) D.28114;
      goto <D.25626>;
      <D.25625>:
      D.28115 = cfg->varinfo;
      D.28110 = (long unsigned int) i;
      D.28116 = D.28110 * 8;
      D.28117 = D.28115 + D.28116;
      inst = *D.28117;
      D.28103 = cfg->vars;
      D.28110 = (long unsigned int) i;
      D.28118 = D.28110 * 80;
      vmv = D.28103 + D.28118;
      D.28121 = inst->flags;
      D.28122 = (int) D.28121;
      D.28123 = D.28122 & 2;
      if (D.28123 != 0) goto <D.28119>; else goto <D.28124>;
      <D.28124>:
      D.28125 = inst->opcode;
      if (D.28125 == 366) goto <D.28119>; else goto <D.28126>;
      <D.28126>:
      D.28125 = inst->opcode;
      if (D.28125 == 367) goto <D.28119>; else goto <D.28120>;
      <D.28119>:
      // predicted unlikely by continue predictor.
      goto <D.25624>;
      <D.28120>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25624>:
      i = i + 1;
      <D.25626>:
      i.35 = (unsigned int) i;
      D.28100 = cfg->num_varinfo;
      if (i.35 < D.28100) goto <D.25625>; else goto <D.25627>;
      <D.25627>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 8;
      l = vars;
      goto <D.25654>;
      <D.25653>:
      vmv = l->data;
      D.28115 = cfg->varinfo;
      D.28127 = vmv->idx;
      D.28128 = (long unsigned int) D.28127;
      D.28129 = D.28128 * 8;
      D.28130 = D.28115 + D.28129;
      inst = *D.28130;
      D.28131 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.28131);
      D.28132 = cfg->gsharedvt;
      if (D.28132 != 0) goto <D.28133>; else goto <D.28134>;
      <D.28133>:
      D.28135 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.28135 != 0) goto <D.28136>; else goto <D.28137>;
      <D.28136>:
      // predicted unlikely by continue predictor.
      goto <D.25628>;
      <D.28137>:
      <D.28134>:
      D.28140 = inst->backend.is_pinvoke;
      if (D.28140 != 0) goto <D.28141>; else goto <D.28138>;
      <D.28141>:
      D.28142 = mono_type_is_struct (t);
      if (D.28142 != 0) goto <D.28143>; else goto <D.28138>;
      <D.28143>:
      D.28144 = t->type;
      if (D.28144 != 22) goto <D.28145>; else goto <D.28138>;
      <D.28145>:
      D.28146 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.28146, &align);
      goto <D.28139>;
      <D.28138>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.36 = ialign;
            ialign.37 = (unsigned int) ialign.36;
            align = ialign.37;
            D.28149 = mono_class_from_mono_type (t);
            D.28150 = D.28149->exception_type;
            if (D.28150 != 0) goto <D.28151>; else goto <D.28152>;
            <D.28151>:
            mono_cfg_set_exception (cfg, 7);
            <D.28152>:
            if (0 != 0) goto <D.28153>; else goto <D.28154>;
            <D.28153>:
            align = 16;
            <D.28154>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.28139>:
      reuse_slot = 1;
      D.28155 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28156 = D.28155 & 281474976710656;
      if (D.28156 != 0) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      reuse_slot = 0;
      <D.28158>:
      D.28159 = BIT_FIELD_REF <*t, 64, 64>;
      D.28160 = D.28159 & 1073741824;
      if (D.28160 != 0) goto <D.28161>; else goto <D.28162>;
      <D.28161>:
      slot_info = scalar_stack_slots + 768;
      goto <D.28163>;
      <D.28162>:
      D.28144 = t->type;
      D.28164 = (int) D.28144;
      switch (D.28164) <default: <D.25647>, case 10: <D.25639>, case 14: <D.25644>, case 15: <D.25636>, case 17: <D.25632>, case 18: <D.25640>, case 19: <D.25645>, case 20: <D.25642>, case 21: <D.25630>, case 24: <D.25637>, case 25: <D.25638>, case 28: <D.25641>, case 29: <D.25643>, case 30: <D.25646>>
      <D.25630>:
      D.28165 = mono_type_generic_inst_is_valuetype (t);
      if (D.28165 == 0) goto <D.28166>; else goto <D.28167>;
      <D.28166>:
      D.28144 = t->type;
      D.28168 = (long unsigned int) D.28144;
      D.28169 = D.28168 * 32;
      slot_info = scalar_stack_slots + D.28169;
      goto <D.25631>;
      <D.28167>:
      <D.25632>:
      if (vtype_stack_slots == 0B) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      D.28108 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.28108, 8192);
      <D.28171>:
      i = 0;
      goto <D.25635>;
      <D.25634>:
      D.28172 = t->data.klass;
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      D.28174 = vtype_stack_slots + D.28173;
      D.28175 = D.28174->vtype;
      if (D.28172 == D.28175) goto <D.25633>; else goto <D.28176>;
      <D.28176>:
      i = i + 1;
      <D.25635>:
      if (i < nvtypes) goto <D.25634>; else goto <D.25633>;
      <D.25633>:
      if (i < nvtypes) goto <D.28177>; else goto <D.28178>;
      <D.28177>:
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      slot_info = vtype_stack_slots + D.28173;
      goto <D.28179>;
      <D.28178>:
      D.28180 = nvtypes > 255;
      D.28181 = (long int) D.28180;
      D.28182 = __builtin_expect (D.28181, 0);
      if (D.28182 != 0) goto <D.28183>; else goto <D.28184>;
      <D.28183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.28184>:
      D.28185 = (long unsigned int) nvtypes;
      D.28186 = D.28185 * 32;
      D.28187 = vtype_stack_slots + D.28186;
      D.28172 = t->data.klass;
      D.28187->vtype = D.28172;
      D.28185 = (long unsigned int) nvtypes;
      D.28186 = D.28185 * 32;
      slot_info = vtype_stack_slots + D.28186;
      nvtypes = nvtypes + 1;
      <D.28179>:
      D.28155 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28188 = D.28155 & 562949953421312;
      if (D.28188 != 0) goto <D.28189>; else goto <D.28190>;
      <D.28189>:
      reuse_slot = 0;
      <D.28190>:
      goto <D.25631>;
      <D.25636>:
      <D.25637>:
      <D.25638>:
      <D.25639>:
      D.28155 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28191 = D.28155 & 1125899906842624;
      if (D.28191 != 0) goto <D.28192>; else goto <D.28193>;
      <D.28192>:
      slot_info = scalar_stack_slots + 768;
      goto <D.25631>;
      <D.28193>:
      <D.25640>:
      <D.25641>:
      <D.25642>:
      <D.25643>:
      <D.25644>:
      slot_info = scalar_stack_slots + 576;
      D.28155 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.28188 = D.28155 & 562949953421312;
      if (D.28188 != 0) goto <D.28194>; else goto <D.28195>;
      <D.28194>:
      reuse_slot = 0;
      <D.28195>:
      goto <D.25631>;
      <D.25645>:
      <D.25646>:
      D.28144 = t->type;
      D.28168 = (long unsigned int) D.28144;
      D.28169 = D.28168 * 32;
      slot_info = scalar_stack_slots + D.28169;
      goto <D.25631>;
      <D.25647>:
      D.28144 = t->type;
      D.28168 = (long unsigned int) D.28144;
      D.28169 = D.28168 * 32;
      slot_info = scalar_stack_slots + D.28169;
      goto <D.25631>;
      <D.25631>:
      <D.28163>:
      slot = 16777215;
      D.28196 = cfg->comp_done;
      D.28197 = D.28196 & 16;
      if (D.28197 != 0) goto <D.28198>; else goto <D.28199>;
      <D.28198>:
      goto <D.25651>;
      <D.25650>:
      {
        struct MonoMethodVar * amv;

        D.28200 = slot_info->active;
        amv = D.28200->data;
        D.28201 = amv->range.last_use.abs_pos;
        D.28202 = vmv->range.first_use.abs_pos;
        if (D.28201 > D.28202) goto <D.25649>; else goto <D.28203>;
        <D.28203>:
        D.28200 = slot_info->active;
        D.28200 = slot_info->active;
        D.28204 = monoeg_g_list_delete_link (D.28200, D.28200);
        slot_info->active = D.28204;
        D.28108 = cfg->mempool;
        D.28205 = slot_info->slots;
        D.28206 = amv->idx;
        D.28207 = (long unsigned int) D.28206;
        D.28208 = D.28207 * 4;
        D.28209 = offsets + D.28208;
        D.28210 = *D.28209;
        D.28211 = (long int) D.28210;
        D.28212 = (void *) D.28211;
        D.28213 = g_slist_prepend_mempool (D.28108, D.28205, D.28212);
        slot_info->slots = D.28213;
      }
      <D.25651>:
      D.28200 = slot_info->active;
      if (D.28200 != 0B) goto <D.25650>; else goto <D.25649>;
      <D.25649>:
      D.28121 = inst->flags;
      D.28122 = (int) D.28121;
      D.28214 = D.28122 & 20;
      if (D.28214 == 0) goto <D.28215>; else goto <D.28216>;
      <D.28215>:
      D.28205 = slot_info->slots;
      if (D.28205 != 0B) goto <D.28217>; else goto <D.28218>;
      <D.28217>:
      D.28205 = slot_info->slots;
      D.28219 = D.28205->data;
      D.28220 = (long int) D.28219;
      slot = (int) D.28220;
      D.28205 = slot_info->slots;
      D.28221 = D.28205->next;
      slot_info->slots = D.28221;
      <D.28218>:
      D.28200 = slot_info->active;
      D.28222 = mono_varlist_insert_sorted (cfg, D.28200, vmv, 1);
      slot_info->active = D.28222;
      <D.28216>:
      <D.28199>:
      {
        static int count = 0;

        count.38 = count;
        count.39 = count.38 + 1;
        count = count.39;
      }
      D.28121 = inst->flags;
      D.28122 = (int) D.28121;
      D.28225 = D.28122 & 32;
      if (D.28225 != 0) goto <D.28226>; else goto <D.28227>;
      <D.28226>:
      size = 344;
      align = 8;
      reuse_slot = 0;
      <D.28227>:
      if (reuse_slot == 0) goto <D.28228>; else goto <D.28229>;
      <D.28228>:
      slot = 16777215;
      <D.28229>:
      if (slot == 16777215) goto <D.28230>; else goto <D.28231>;
      <D.28230>:
      D.28232 = mono_type_is_struct (t);
      if (D.28232 != 0) goto <D.28233>; else goto <D.28234>;
      <D.28233>:
      align.40 = align;
      align.41 = MAX_EXPR <align.40, 8>;
      align = align.41;
      D.28238 = mono_class_from_mono_type (t);
      D.28239 = mono_class_min_align (D.28238);
      D.28240 = (unsigned int) D.28239;
      align.40 = align;
      if (D.28240 >= align.40) goto <D.28241>; else goto <D.28242>;
      <D.28241>:
      D.28243 = mono_class_from_mono_type (t);
      D.28244 = mono_class_min_align (D.28243);
      iftmp.42 = (guint32) D.28244;
      goto <D.28245>;
      <D.28242>:
      iftmp.42 = align;
      <D.28245>:
      align = iftmp.42;
      align.40 = align;
      size.43 = (unsigned int) size;
      D.28247 = align.40 + size.43;
      D.28248 = D.28247 + 4294967295;
      align.40 = align;
      D.28249 = -align.40;
      D.28250 = D.28248 & D.28249;
      size = (int) D.28250;
      <D.28234>:
      if (backward != 0) goto <D.28251>; else goto <D.28252>;
      <D.28251>:
      offset = offset + size;
      align.40 = align;
      offset.44 = (unsigned int) offset;
      D.28254 = align.40 + offset.44;
      D.28255 = D.28254 + 4294967295;
      offset = (int) D.28255;
      align.40 = align;
      D.28249 = -align.40;
      offset.44 = (unsigned int) offset;
      D.28256 = D.28249 & offset.44;
      offset = (int) D.28256;
      slot = offset;
      goto <D.28257>;
      <D.28252>:
      align.40 = align;
      offset.44 = (unsigned int) offset;
      D.28254 = align.40 + offset.44;
      D.28255 = D.28254 + 4294967295;
      offset = (int) D.28255;
      align.40 = align;
      D.28249 = -align.40;
      offset.44 = (unsigned int) offset;
      D.28256 = D.28249 & offset.44;
      offset = (int) D.28256;
      slot = offset;
      offset = offset + size;
      <D.28257>:
      D.28258 = *stack_align;
      align.40 = align;
      D.28259 = MAX_EXPR <D.28258, align.40>;
      *stack_align = D.28259;
      <D.28231>:
      D.28127 = vmv->idx;
      D.28128 = (long unsigned int) D.28127;
      D.28260 = D.28128 * 4;
      D.28261 = offsets + D.28260;
      *D.28261 = slot;
      <D.25628>:
      l = l->next;
      <D.25654>:
      if (l != 0B) goto <D.25653>; else goto <D.25655>;
      <D.25655>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25657>;
      <D.25656>:
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      D.28262 = scalar_stack_slots + D.28173;
      D.28263 = D.28262->active;
      if (D.28263 != 0B) goto <D.28264>; else goto <D.28265>;
      <D.28264>:
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      D.28262 = scalar_stack_slots + D.28173;
      D.28263 = D.28262->active;
      monoeg_g_list_free (D.28263);
      <D.28265>:
      i = i + 1;
      <D.25657>:
      if (i <= 68) goto <D.25656>; else goto <D.25658>;
      <D.25658>:
      i = 0;
      goto <D.25660>;
      <D.25659>:
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      D.28174 = vtype_stack_slots + D.28173;
      D.28266 = D.28174->active;
      if (D.28266 != 0B) goto <D.28267>; else goto <D.28268>;
      <D.28267>:
      D.28110 = (long unsigned int) i;
      D.28173 = D.28110 * 32;
      D.28174 = vtype_stack_slots + D.28173;
      D.28266 = D.28174->active;
      monoeg_g_list_free (D.28266);
      <D.28268>:
      i = i + 1;
      <D.25660>:
      if (i < nvtypes) goto <D.25659>; else goto <D.25661>;
      <D.25661>:
      D.28269 = cfg->stat_locals_stack_size;
      D.28270 = D.28269 + offset;
      cfg->stat_locals_stack_size = D.28270;
      offset.44 = (unsigned int) offset;
      *stack_size = offset.44;
      D.28107 = offsets;
      return D.28107;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.28273;
  unsigned int D.28274;
  unsigned int D.28275;
  long unsigned int D.28276;
  long unsigned int D.28277;
  gint32 * D.28278;
  unsigned int i.45;
  unsigned int D.28280;
  struct MonoInst * * D.28281;
  long unsigned int D.28282;
  struct MonoInst * * D.28283;
  struct MonoMethodVar * D.28284;
  long unsigned int D.28285;
  unsigned char D.28288;
  int D.28289;
  int D.28290;
  short unsigned int D.28292;
  struct GList * D.28294;
  unsigned int D.28295;
  long unsigned int D.28296;
  long unsigned int D.28297;
  struct MonoInst * * D.28298;
  struct MonoType * D.28299;
  int D.28300;
  int D.28303;
  int D.28308;
  int D.28310;
  unsigned char D.28312;
  struct MonoClass * D.28314;
  int ialign.46;
  unsigned int ialign.47;
  long unsigned int D.28319;
  long unsigned int D.28320;
  int D.28323;
  int D.28324;
  long unsigned int D.28327;
  long unsigned int D.28328;
  struct MonoClass * D.28331;
  long unsigned int D.28332;
  struct StackSlotInfo * D.28333;
  struct MonoClass * D.28334;
  _Bool D.28339;
  long int D.28340;
  long int D.28341;
  long unsigned int D.28344;
  long unsigned int D.28345;
  struct StackSlotInfo * D.28346;
  long unsigned int D.28347;
  long unsigned int D.28350;
  unsigned int D.28355;
  unsigned int D.28356;
  struct MonoLiveInterval * D.28359;
  struct MonoLiveRange2 * D.28360;
  int D.28363;
  unsigned char D.28367;
  struct MonoLiveInterval * D.28371;
  struct MonoLiveRange2 * D.28372;
  int D.28373;
  struct GList * D.28376;
  struct GList * D.28377;
  struct GSList * D.28378;
  unsigned int D.28379;
  long unsigned int D.28380;
  long unsigned int D.28381;
  gint32 * D.28382;
  int D.28383;
  long int D.28384;
  void * D.28385;
  struct GSList * D.28386;
  int D.28387;
  struct GList * D.28390;
  struct GList * D.28391;
  struct GList * D.28392;
  struct MonoLiveInterval * D.28393;
  struct MonoLiveRange2 * D.28394;
  int D.28395;
  struct GList * D.28398;
  int D.28399;
  struct GList * D.28402;
  struct GList * D.28403;
  void * D.28408;
  long int D.28409;
  struct GSList * D.28410;
  struct GList * D.28411;
  int D.28412;
  int D.28419;
  unsigned int align.48;
  unsigned int align.49;
  guint32 iftmp.50;
  struct MonoClass * D.28425;
  int D.28426;
  unsigned int D.28427;
  struct MonoClass * D.28430;
  int D.28431;
  unsigned int offset.51;
  unsigned int D.28436;
  unsigned int D.28437;
  unsigned int D.28438;
  unsigned int D.28439;
  unsigned int D.28441;
  long unsigned int D.28444;
  gint32 * D.28445;
  struct StackSlotInfo * D.28446;
  struct GList * D.28447;
  struct GList * D.28450;
  int D.28453;
  int D.28454;
  gint32 * D.28455;
  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.28273 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.28273, 2208);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.28273 = cfg->mempool;
      D.28274 = cfg->num_varinfo;
      D.28275 = D.28274 * 4;
      offsets = mono_mempool_alloc (D.28273, D.28275);
      i = 0;
      goto <D.25549>;
      <D.25548>:
      D.28276 = (long unsigned int) i;
      D.28277 = D.28276 * 4;
      D.28278 = offsets + D.28277;
      *D.28278 = -1;
      i = i + 1;
      <D.25549>:
      i.45 = (unsigned int) i;
      D.28274 = cfg->num_varinfo;
      if (i.45 < D.28274) goto <D.25548>; else goto <D.25550>;
      <D.25550>:
      D.28280 = cfg->locals_start;
      i = (int) D.28280;
      goto <D.25553>;
      <D.25552>:
      D.28281 = cfg->varinfo;
      D.28276 = (long unsigned int) i;
      D.28282 = D.28276 * 8;
      D.28283 = D.28281 + D.28282;
      inst = *D.28283;
      D.28284 = cfg->vars;
      D.28276 = (long unsigned int) i;
      D.28285 = D.28276 * 80;
      vmv = D.28284 + D.28285;
      D.28288 = inst->flags;
      D.28289 = (int) D.28288;
      D.28290 = D.28289 & 2;
      if (D.28290 != 0) goto <D.28286>; else goto <D.28291>;
      <D.28291>:
      D.28292 = inst->opcode;
      if (D.28292 == 366) goto <D.28286>; else goto <D.28293>;
      <D.28293>:
      D.28292 = inst->opcode;
      if (D.28292 == 367) goto <D.28286>; else goto <D.28287>;
      <D.28286>:
      // predicted unlikely by continue predictor.
      goto <D.25551>;
      <D.28287>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.25551>:
      i = i + 1;
      <D.25553>:
      i.45 = (unsigned int) i;
      D.28274 = cfg->num_varinfo;
      if (i.45 < D.28274) goto <D.25552>; else goto <D.25554>;
      <D.25554>:
      D.28294 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.28294, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.25591>;
      <D.25590>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.28281 = cfg->varinfo;
        D.28295 = vmv->idx;
        D.28296 = (long unsigned int) D.28295;
        D.28297 = D.28296 * 8;
        D.28298 = D.28281 + D.28297;
        inst = *D.28298;
        D.28299 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.28299);
        D.28300 = cfg->gsharedvt;
        if (D.28300 != 0) goto <D.28301>; else goto <D.28302>;
        <D.28301>:
        D.28303 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.28303 != 0) goto <D.28304>; else goto <D.28305>;
        <D.28304>:
        // predicted unlikely by continue predictor.
        goto <D.25556>;
        <D.28305>:
        <D.28302>:
        D.28308 = inst->backend.is_pinvoke;
        if (D.28308 != 0) goto <D.28309>; else goto <D.28306>;
        <D.28309>:
        D.28310 = mono_type_is_struct (t);
        if (D.28310 != 0) goto <D.28311>; else goto <D.28306>;
        <D.28311>:
        D.28312 = t->type;
        if (D.28312 != 22) goto <D.28313>; else goto <D.28306>;
        <D.28313>:
        D.28314 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.28314, &align);
        goto <D.28307>;
        <D.28306>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.46 = ialign;
              ialign.47 = (unsigned int) ialign.46;
              align = ialign.47;
              if (0 != 0) goto <D.28317>; else goto <D.28318>;
              <D.28317>:
              align = 16;
              <D.28318>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.28307>:
        reuse_slot = 1;
        D.28319 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28320 = D.28319 & 281474976710656;
        if (D.28320 != 0) goto <D.28321>; else goto <D.28322>;
        <D.28321>:
        reuse_slot = 0;
        <D.28322>:
        D.28312 = t->type;
        D.28323 = (int) D.28312;
        switch (D.28323) <default: <D.25573>, case 10: <D.25567>, case 14: <D.25572>, case 15: <D.25564>, case 17: <D.25560>, case 18: <D.25568>, case 20: <D.25570>, case 21: <D.25558>, case 24: <D.25565>, case 25: <D.25566>, case 28: <D.25569>, case 29: <D.25571>>
        <D.25558>:
        D.28324 = mono_type_generic_inst_is_valuetype (t);
        if (D.28324 == 0) goto <D.28325>; else goto <D.28326>;
        <D.28325>:
        D.28312 = t->type;
        D.28327 = (long unsigned int) D.28312;
        D.28328 = D.28327 * 32;
        slot_info = scalar_stack_slots + D.28328;
        goto <D.25559>;
        <D.28326>:
        <D.25560>:
        if (vtype_stack_slots == 0B) goto <D.28329>; else goto <D.28330>;
        <D.28329>:
        D.28273 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.28273, 8192);
        <D.28330>:
        i = 0;
        goto <D.25563>;
        <D.25562>:
        D.28331 = t->data.klass;
        D.28276 = (long unsigned int) i;
        D.28332 = D.28276 * 32;
        D.28333 = vtype_stack_slots + D.28332;
        D.28334 = D.28333->vtype;
        if (D.28331 == D.28334) goto <D.25561>; else goto <D.28335>;
        <D.28335>:
        i = i + 1;
        <D.25563>:
        if (i < nvtypes) goto <D.25562>; else goto <D.25561>;
        <D.25561>:
        if (i < nvtypes) goto <D.28336>; else goto <D.28337>;
        <D.28336>:
        D.28276 = (long unsigned int) i;
        D.28332 = D.28276 * 32;
        slot_info = vtype_stack_slots + D.28332;
        goto <D.28338>;
        <D.28337>:
        D.28339 = nvtypes > 255;
        D.28340 = (long int) D.28339;
        D.28341 = __builtin_expect (D.28340, 0);
        if (D.28341 != 0) goto <D.28342>; else goto <D.28343>;
        <D.28342>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.28343>:
        D.28344 = (long unsigned int) nvtypes;
        D.28345 = D.28344 * 32;
        D.28346 = vtype_stack_slots + D.28345;
        D.28331 = t->data.klass;
        D.28346->vtype = D.28331;
        D.28344 = (long unsigned int) nvtypes;
        D.28345 = D.28344 * 32;
        slot_info = vtype_stack_slots + D.28345;
        nvtypes = nvtypes + 1;
        <D.28338>:
        D.28319 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28347 = D.28319 & 562949953421312;
        if (D.28347 != 0) goto <D.28348>; else goto <D.28349>;
        <D.28348>:
        reuse_slot = 0;
        <D.28349>:
        goto <D.25559>;
        <D.25564>:
        <D.25565>:
        <D.25566>:
        <D.25567>:
        D.28319 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28350 = D.28319 & 1125899906842624;
        if (D.28350 != 0) goto <D.28351>; else goto <D.28352>;
        <D.28351>:
        slot_info = scalar_stack_slots + 768;
        goto <D.25559>;
        <D.28352>:
        <D.25568>:
        <D.25569>:
        <D.25570>:
        <D.25571>:
        <D.25572>:
        slot_info = scalar_stack_slots + 576;
        D.28319 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28347 = D.28319 & 562949953421312;
        if (D.28347 != 0) goto <D.28353>; else goto <D.28354>;
        <D.28353>:
        reuse_slot = 0;
        <D.28354>:
        goto <D.25559>;
        <D.25573>:
        D.28312 = t->type;
        D.28327 = (long unsigned int) D.28312;
        D.28328 = D.28327 * 32;
        slot_info = scalar_stack_slots + D.28328;
        <D.25559>:
        slot = 16777215;
        D.28355 = cfg->comp_done;
        D.28356 = D.28355 & 16;
        if (D.28356 != 0) goto <D.28357>; else goto <D.28358>;
        <D.28357>:
        {
          int pos;
          gboolean changed;

          D.28359 = current->interval;
          D.28360 = D.28359->range;
          if (D.28360 == 0B) goto <D.28361>; else goto <D.28362>;
          <D.28361>:
          D.28288 = inst->flags;
          D.28289 = (int) D.28288;
          D.28363 = D.28289 & 20;
          if (D.28363 != 0) goto <D.28364>; else goto <D.28365>;
          <D.28364>:
          pos = -1;
          goto <D.28366>;
          <D.28365>:
          D.28288 = inst->flags;
          D.28367 = D.28288 | 2;
          inst->flags = D.28367;
          // predicted unlikely by continue predictor.
          goto <D.25556>;
          <D.28366>:
          goto <D.28368>;
          <D.28362>:
          D.28359 = current->interval;
          D.28360 = D.28359->range;
          pos = D.28360->from;
          <D.28368>:
          D.28359 = current->interval;
          D.28360 = D.28359->range;
          if (D.28360 != 0B) goto <D.28369>; else goto <D.28370>;
          <D.28369>:
          <D.28370>:
          changed = 1;
          goto <D.25581>;
          <D.25580>:
          changed = 0;
          l = slot_info->active;
          goto <D.25579>;
          <D.25578>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28371 = v->interval;
            D.28372 = D.28371->last_range;
            D.28373 = D.28372->to;
            if (D.28373 < pos) goto <D.28374>; else goto <D.28375>;
            <D.28374>:
            D.28376 = slot_info->active;
            D.28377 = monoeg_g_list_delete_link (D.28376, l);
            slot_info->active = D.28377;
            D.28273 = cfg->mempool;
            D.28378 = slot_info->slots;
            D.28379 = v->idx;
            D.28380 = (long unsigned int) D.28379;
            D.28381 = D.28380 * 4;
            D.28382 = offsets + D.28381;
            D.28383 = *D.28382;
            D.28384 = (long int) D.28383;
            D.28385 = (void *) D.28384;
            D.28386 = g_slist_prepend_mempool (D.28273, D.28378, D.28385);
            slot_info->slots = D.28386;
            changed = 1;
            goto <D.25577>;
            <D.28375>:
            D.28371 = v->interval;
            D.28387 = mono_linterval_covers (D.28371, pos);
            if (D.28387 == 0) goto <D.28388>; else goto <D.28389>;
            <D.28388>:
            D.28390 = slot_info->inactive;
            D.28391 = monoeg_g_list_append (D.28390, v);
            slot_info->inactive = D.28391;
            D.28376 = slot_info->active;
            D.28392 = monoeg_g_list_delete_link (D.28376, l);
            slot_info->active = D.28392;
            changed = 1;
            goto <D.25577>;
            <D.28389>:
          }
          l = l->next;
          <D.25579>:
          if (l != 0B) goto <D.25578>; else goto <D.25577>;
          <D.25577>:
          <D.25581>:
          if (changed != 0) goto <D.25580>; else goto <D.25582>;
          <D.25582>:
          changed = 1;
          goto <D.25588>;
          <D.25587>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.25586>;
          <D.25585>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.28393 = v->interval;
            D.28394 = D.28393->last_range;
            D.28395 = D.28394->to;
            if (D.28395 < pos) goto <D.28396>; else goto <D.28397>;
            <D.28396>:
            D.28390 = slot_info->inactive;
            D.28398 = monoeg_g_list_delete_link (D.28390, l);
            slot_info->inactive = D.28398;
            changed = 1;
            goto <D.25584>;
            <D.28397>:
            D.28393 = v->interval;
            D.28399 = mono_linterval_covers (D.28393, pos);
            if (D.28399 != 0) goto <D.28400>; else goto <D.28401>;
            <D.28400>:
            D.28376 = slot_info->active;
            D.28402 = monoeg_g_list_append (D.28376, v);
            slot_info->active = D.28402;
            D.28390 = slot_info->inactive;
            D.28403 = monoeg_g_list_delete_link (D.28390, l);
            slot_info->inactive = D.28403;
            changed = 1;
            goto <D.25584>;
            <D.28401>:
          }
          l = l->next;
          <D.25586>:
          if (l != 0B) goto <D.25585>; else goto <D.25584>;
          <D.25584>:
          <D.25588>:
          if (changed != 0) goto <D.25587>; else goto <D.25589>;
          <D.25589>:
          D.28288 = inst->flags;
          D.28289 = (int) D.28288;
          D.28363 = D.28289 & 20;
          if (D.28363 == 0) goto <D.28404>; else goto <D.28405>;
          <D.28404>:
          D.28378 = slot_info->slots;
          if (D.28378 != 0B) goto <D.28406>; else goto <D.28407>;
          <D.28406>:
          D.28378 = slot_info->slots;
          D.28408 = D.28378->data;
          D.28409 = (long int) D.28408;
          slot = (int) D.28409;
          D.28378 = slot_info->slots;
          D.28410 = D.28378->next;
          slot_info->slots = D.28410;
          <D.28407>:
          D.28376 = slot_info->active;
          D.28411 = mono_varlist_insert_sorted (cfg, D.28376, vmv, 1);
          slot_info->active = D.28411;
          <D.28405>:
        }
        <D.28358>:
        D.28288 = inst->flags;
        D.28289 = (int) D.28288;
        D.28412 = D.28289 & 32;
        if (D.28412 != 0) goto <D.28413>; else goto <D.28414>;
        <D.28413>:
        size = 344;
        align = 8;
        reuse_slot = 0;
        <D.28414>:
        if (reuse_slot == 0) goto <D.28415>; else goto <D.28416>;
        <D.28415>:
        slot = 16777215;
        <D.28416>:
        if (slot == 16777215) goto <D.28417>; else goto <D.28418>;
        <D.28417>:
        D.28419 = mono_type_is_struct (t);
        if (D.28419 != 0) goto <D.28420>; else goto <D.28421>;
        <D.28420>:
        align.48 = align;
        align.49 = MAX_EXPR <align.48, 8>;
        align = align.49;
        D.28425 = mono_class_from_mono_type (t);
        D.28426 = mono_class_min_align (D.28425);
        D.28427 = (unsigned int) D.28426;
        align.48 = align;
        if (D.28427 >= align.48) goto <D.28428>; else goto <D.28429>;
        <D.28428>:
        D.28430 = mono_class_from_mono_type (t);
        D.28431 = mono_class_min_align (D.28430);
        iftmp.50 = (guint32) D.28431;
        goto <D.28432>;
        <D.28429>:
        iftmp.50 = align;
        <D.28432>:
        align = iftmp.50;
        <D.28421>:
        if (backward != 0) goto <D.28433>; else goto <D.28434>;
        <D.28433>:
        offset = offset + size;
        align.48 = align;
        offset.51 = (unsigned int) offset;
        D.28436 = align.48 + offset.51;
        D.28437 = D.28436 + 4294967295;
        offset = (int) D.28437;
        align.48 = align;
        D.28438 = -align.48;
        offset.51 = (unsigned int) offset;
        D.28439 = D.28438 & offset.51;
        offset = (int) D.28439;
        slot = offset;
        goto <D.28440>;
        <D.28434>:
        align.48 = align;
        offset.51 = (unsigned int) offset;
        D.28436 = align.48 + offset.51;
        D.28437 = D.28436 + 4294967295;
        offset = (int) D.28437;
        align.48 = align;
        D.28438 = -align.48;
        offset.51 = (unsigned int) offset;
        D.28439 = D.28438 & offset.51;
        offset = (int) D.28439;
        slot = offset;
        offset = offset + size;
        <D.28440>:
        D.28441 = *stack_align;
        if (D.28441 == 0) goto <D.28442>; else goto <D.28443>;
        <D.28442>:
        align.48 = align;
        *stack_align = align.48;
        <D.28443>:
        <D.28418>:
        D.28295 = vmv->idx;
        D.28296 = (long unsigned int) D.28295;
        D.28444 = D.28296 * 4;
        D.28445 = offsets + D.28444;
        *D.28445 = slot;
      }
      <D.25556>:
      unhandled = unhandled->next;
      <D.25591>:
      if (unhandled != 0B) goto <D.25590>; else goto <D.25592>;
      <D.25592>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.25594>;
      <D.25593>:
      D.28276 = (long unsigned int) i;
      D.28332 = D.28276 * 32;
      D.28446 = scalar_stack_slots + D.28332;
      D.28447 = D.28446->active;
      if (D.28447 != 0B) goto <D.28448>; else goto <D.28449>;
      <D.28448>:
      D.28276 = (long unsigned int) i;
      D.28332 = D.28276 * 32;
      D.28446 = scalar_stack_slots + D.28332;
      D.28447 = D.28446->active;
      monoeg_g_list_free (D.28447);
      <D.28449>:
      i = i + 1;
      <D.25594>:
      if (i <= 68) goto <D.25593>; else goto <D.25595>;
      <D.25595>:
      i = 0;
      goto <D.25597>;
      <D.25596>:
      D.28276 = (long unsigned int) i;
      D.28332 = D.28276 * 32;
      D.28333 = vtype_stack_slots + D.28332;
      D.28450 = D.28333->active;
      if (D.28450 != 0B) goto <D.28451>; else goto <D.28452>;
      <D.28451>:
      D.28276 = (long unsigned int) i;
      D.28332 = D.28276 * 32;
      D.28333 = vtype_stack_slots + D.28332;
      D.28450 = D.28333->active;
      monoeg_g_list_free (D.28450);
      <D.28452>:
      i = i + 1;
      <D.25597>:
      if (i < nvtypes) goto <D.25596>; else goto <D.25598>;
      <D.25598>:
      D.28453 = cfg->stat_locals_stack_size;
      D.28454 = D.28453 + offset;
      cfg->stat_locals_stack_size = D.28454;
      offset.51 = (unsigned int) offset;
      *stack_size = offset.51;
      D.28455 = offsets;
      return D.28455;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.28460;
  struct MonoLiveInterval * D.28462;
  struct MonoLiveRange2 * D.28463;
  struct MonoLiveInterval * D.28465;
  struct MonoLiveRange2 * D.28466;
  int D.28468;
  int D.28469;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.28458>; else goto <D.28459>;
  <D.28458>:
  D.28460 = 0;
  return D.28460;
  <D.28459>:
  D.28462 = v1->interval;
  D.28463 = D.28462->range;
  if (D.28463 != 0B) goto <D.28464>; else goto <D.28461>;
  <D.28464>:
  D.28465 = v2->interval;
  D.28466 = D.28465->range;
  if (D.28466 != 0B) goto <D.28467>; else goto <D.28461>;
  <D.28467>:
  D.28462 = v1->interval;
  D.28463 = D.28462->range;
  D.28468 = D.28463->from;
  D.28465 = v2->interval;
  D.28466 = D.28465->range;
  D.28469 = D.28466->from;
  D.28460 = D.28468 - D.28469;
  return D.28460;
  <D.28461>:
  D.28462 = v1->interval;
  D.28463 = D.28462->range;
  if (D.28463 != 0B) goto <D.28470>; else goto <D.28471>;
  <D.28470>:
  D.28460 = -1;
  return D.28460;
  <D.28471>:
  D.28460 = 1;
  return D.28460;
}


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

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


mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.52;
  _Bool D.28476;
  long int D.28477;
  long int D.28478;
  int D.28481;
  unsigned char D.28482;
  int D.28483;
  int D.28484;
  int D.28485;
  int D.28486;
  short int * emul_opcode_opcodes.53;
  long unsigned int D.28490;
  long unsigned int D.28491;
  short int * D.28492;
  short int D.28493;
  int D.28494;
  struct MonoJitICallInfo * D.28497;
  struct MonoJitICallInfo * * emul_opcode_map.54;
  long unsigned int D.28499;
  struct MonoJitICallInfo * * D.28500;
  short int emul_opcode_num.55;
  int D.28502;

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

    i = 0;
    goto <D.25672>;
    <D.25671>:
    emul_opcode_opcodes.53 = emul_opcode_opcodes;
    D.28490 = (long unsigned int) i;
    D.28491 = D.28490 * 2;
    D.28492 = emul_opcode_opcodes.53 + D.28491;
    D.28493 = *D.28492;
    D.28494 = (int) D.28493;
    if (D.28494 == opcode) goto <D.28495>; else goto <D.28496>;
    <D.28495>:
    emul_opcode_map.54 = emul_opcode_map;
    D.28490 = (long unsigned int) i;
    D.28499 = D.28490 * 8;
    D.28500 = emul_opcode_map.54 + D.28499;
    D.28497 = *D.28500;
    return D.28497;
    <D.28496>:
    i = i + 1;
    <D.25672>:
    emul_opcode_num.55 = emul_opcode_num;
    D.28502 = (int) emul_opcode_num.55;
    if (D.28502 > i) goto <D.25671>; else goto <D.25673>;
    <D.25673>:
  }
  <D.28488>:
  D.28497 = 0B;
  return D.28497;
}


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

  D.28504 = bb->last_ins;
  if (D.28504 != 0B) goto <D.28505>; else goto <D.28506>;
  <D.28505>:
  D.28504 = bb->last_ins;
  D.28504->next = inst;
  D.28504 = bb->last_ins;
  inst->prev = D.28504;
  bb->last_ins = inst;
  goto <D.28507>;
  <D.28506>:
  bb->last_ins = inst;
  D.28504 = bb->last_ins;
  bb->code = D.28504;
  <D.28507>:
}


mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28512;
  struct MonoInst * D.28516;

  if (ins == 0B) goto <D.28508>; else goto <D.28509>;
  <D.28508>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  ins->prev = ins_to_insert;
  <D.28511>:
  D.28512 = bb->last_ins;
  if (D.28512 == 0B) goto <D.28513>; else goto <D.28514>;
  <D.28513>:
  bb->last_ins = ins_to_insert;
  <D.28514>:
  goto <D.28515>;
  <D.28509>:
  D.28516 = ins->next;
  ins_to_insert->next = D.28516;
  D.28516 = ins->next;
  if (D.28516 != 0B) goto <D.28517>; else goto <D.28518>;
  <D.28517>:
  D.28516 = ins->next;
  D.28516->prev = ins_to_insert;
  <D.28518>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.28512 = bb->last_ins;
  if (D.28512 == ins) goto <D.28519>; else goto <D.28520>;
  <D.28519>:
  bb->last_ins = ins_to_insert;
  <D.28520>:
  <D.28515>:
}


mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.28525;
  struct MonoInst * D.28529;
  struct MonoInst * D.28532;

  if (ins == 0B) goto <D.28521>; else goto <D.28522>;
  <D.28521>:
  ins = bb->code;
  if (ins != 0B) goto <D.28523>; else goto <D.28524>;
  <D.28523>:
  ins->prev = ins_to_insert;
  <D.28524>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.28525 = bb->last_ins;
  if (D.28525 == 0B) goto <D.28526>; else goto <D.28527>;
  <D.28526>:
  bb->last_ins = ins_to_insert;
  <D.28527>:
  goto <D.28528>;
  <D.28522>:
  D.28529 = ins->prev;
  if (D.28529 != 0B) goto <D.28530>; else goto <D.28531>;
  <D.28530>:
  D.28529 = ins->prev;
  D.28529->next = ins_to_insert;
  <D.28531>:
  D.28529 = ins->prev;
  ins_to_insert->prev = D.28529;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.28532 = bb->code;
  if (D.28532 == ins) goto <D.28533>; else goto <D.28534>;
  <D.28533>:
  bb->code = ins_to_insert;
  <D.28534>:
  <D.28528>:
}


mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.28535;
  _Bool D.28536;
  long int D.28537;
  long int D.28538;
  struct MonoInst * D.28541;
  struct MonoInst * D.28544;
  _Bool D.28545;
  long int D.28546;
  long int D.28547;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.25740>;
  <D.25739>:
  D.28535 = ins->prev;
  D.28536 = D.28535 != prev;
  D.28537 = (long int) D.28536;
  D.28538 = __builtin_expect (D.28537, 0);
  if (D.28538 != 0) goto <D.28539>; else goto <D.28540>;
  <D.28539>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.28540>:
  prev = ins;
  ins = ins->next;
  <D.25740>:
  if (ins != 0B) goto <D.25739>; else goto <D.25741>;
  <D.25741>:
  D.28541 = bb->last_ins;
  if (D.28541 != 0B) goto <D.28542>; else goto <D.28543>;
  <D.28542>:
  D.28541 = bb->last_ins;
  D.28544 = D.28541->next;
  D.28545 = D.28544 != 0B;
  D.28546 = (long int) D.28545;
  D.28547 = __builtin_expect (D.28546, 0);
  if (D.28547 != 0) goto <D.28548>; else goto <D.28549>;
  <D.28548>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.28549>:
  <D.28543>:
}


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

  bb = cfg->bb_entry;
  goto <D.25747>;
  <D.25746>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.25747>:
  if (bb != 0B) goto <D.25746>; else goto <D.25748>;
  <D.25748>:
}


mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.28550;
  struct MonoRegState * D.28553;
  struct GHashTable * D.28556;
  struct GHashTable * D.28559;
  void * D.28562;
  struct GList * D.28563;
  struct GHashTable * D.28564;
  struct GHashTable * D.28565;
  struct MonoMemPool * D.28568;
  struct MonoInst * * D.28569;
  struct MonoMethodVar * D.28570;
  char * D.28571;
  struct GSList * l;

  D.28550 = cfg->header;
  if (D.28550 != 0B) goto <D.28551>; else goto <D.28552>;
  <D.28551>:
  D.28550 = cfg->header;
  mono_metadata_free_mh (D.28550);
  <D.28552>:
  mono_free_loop_info (cfg);
  D.28553 = cfg->rs;
  if (D.28553 != 0B) goto <D.28554>; else goto <D.28555>;
  <D.28554>:
  D.28553 = cfg->rs;
  mono_regstate_free (D.28553);
  <D.28555>:
  D.28556 = cfg->spvars;
  if (D.28556 != 0B) goto <D.28557>; else goto <D.28558>;
  <D.28557>:
  D.28556 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.28556);
  <D.28558>:
  D.28559 = cfg->exvars;
  if (D.28559 != 0B) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  D.28559 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.28559);
  <D.28561>:
  l = cfg->headers_to_free;
  goto <D.25754>;
  <D.25753>:
  D.28562 = l->data;
  mono_metadata_free_mh (D.28562);
  l = l->next;
  <D.25754>:
  if (l != 0B) goto <D.25753>; else goto <D.25755>;
  <D.25755>:
  D.28563 = cfg->ldstr_list;
  monoeg_g_list_free (D.28563);
  D.28564 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.28564);
  D.28565 = cfg->abs_patches;
  if (D.28565 != 0B) goto <D.28566>; else goto <D.28567>;
  <D.28566>:
  D.28565 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.28565);
  <D.28567>:
  D.28568 = cfg->mempool;
  mono_mempool_destroy (D.28568);
  mono_debug_free_method (cfg);
  D.28569 = cfg->varinfo;
  monoeg_g_free (D.28569);
  D.28570 = cfg->vars;
  monoeg_g_free (D.28570);
  D.28571 = cfg->exception_message;
  monoeg_g_free (D.28571);
  monoeg_g_free (cfg);
}


mono_get_jit_tls_key ()
{
  pthread_key_t D.28572;

  D.28572 = mono_jit_tls_id;
  return D.28572;
}


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

  __asm__("lis	%0,mono_jit_tls@tprel@ha
addi	%0,%0, mono_jit_tls@tprel@l
" : "=r" offset);
  D.28574 = offset;
  return D.28574;
}


mono_get_lmf_tls_offset ()
{
  gint32 D.28576;

  D.28576 = -1;
  return D.28576;
}


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

  __asm__("lis	%0,mono_lmf_addr@tprel@ha
addi	%0,%0, mono_lmf_addr@tprel@l
" : "=r" offset);
  D.28578 = offset;
  return D.28578;
}


mono_get_lmf ()
{
  unsigned int mono_jit_tls_id.56;
  struct MonoLMF * D.28583;
  struct MonoJitTlsData * jit_tls;

  mono_jit_tls_id.56 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.56);
  if (jit_tls != 0B) goto <D.28581>; else goto <D.28582>;
  <D.28581>:
  D.28583 = jit_tls->lmf;
  return D.28583;
  <D.28582>:
  D.28583 = 0B;
  return D.28583;
}


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

  D.28585 = mono_lmf_addr;
  return D.28585;
}


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

  D.28587 = mono_get_lmf_addr ();
  *D.28587 = lmf;
}


mono_jit_thread_attach (struct MonoDomain * domain)
{
  void * mono_lmf_addr.57;
  struct MonoInternalThread * D.28593;
  struct MonoDomain * D.28596;
  struct MonoDomain * iftmp.58;
  struct MonoDomain * orig;

  if (domain == 0B) goto <D.28588>; else goto <D.28589>;
  <D.28588>:
  domain = mono_get_root_domain ();
  <D.28589>:
  mono_lmf_addr.57 = mono_lmf_addr;
  if (mono_lmf_addr.57 == 0B) goto <D.28591>; else goto <D.28592>;
  <D.28591>:
  mono_thread_attach (domain);
  D.28593 = mono_thread_internal_current ();
  mono_thread_set_state (D.28593, 4);
  <D.28592>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.28594>; else goto <D.28595>;
  <D.28594>:
  mono_domain_set (domain, 1);
  <D.28595>:
  if (orig != domain) goto <D.28598>; else goto <D.28599>;
  <D.28598>:
  iftmp.58 = orig;
  goto <D.28600>;
  <D.28599>:
  iftmp.58 = 0B;
  <D.28600>:
  D.28596 = iftmp.58;
  return D.28596;
}


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


mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.28604;
  long int D.28605;
  long int D.28606;
  int D.28609;
  int offset;

  switch (key) <default: <D.25838>, case 0: <D.25832>, case 1: <D.25834>, case 2: <D.25835>, case 3: <D.25836>, case 8: <D.25837>>
  <D.25832>:
  offset = mono_thread_get_tls_offset ();
  goto <D.25833>;
  <D.25834>:
  offset = mono_get_jit_tls_offset ();
  goto <D.25833>;
  <D.25835>:
  offset = mono_domain_get_tls_offset ();
  goto <D.25833>;
  <D.25836>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.25833>;
  <D.25837>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.25833>;
  <D.25838>:
  offset = mono_tls_key_get_offset (key);
  D.28604 = offset == -1;
  D.28605 = (long int) D.28604;
  D.28606 = __builtin_expect (D.28605, 0);
  if (D.28606 != 0) goto <D.28607>; else goto <D.28608>;
  <D.28607>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.28608>:
  goto <D.25833>;
  <D.25833>:
  D.28609 = offset;
  return D.28609;
}


mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  gboolean D.28613;
  long unsigned int D.28614;
  long unsigned int D.28615;
  int D.28618;
  _Bool D.28619;

  if (0 != 0) goto <D.28611>; else goto <D.28612>;
  <D.28611>:
  D.28613 = 0;
  return D.28613;
  <D.28612>:
  D.28614 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28615 = D.28614 & 274877906944;
  if (D.28615 != 0) goto <D.28616>; else goto <D.28617>;
  <D.28616>:
  D.28613 = 0;
  return D.28613;
  <D.28617>:
  D.28618 = mini_get_tls_offset (key);
  D.28619 = D.28618 != -1;
  D.28613 = (gboolean) D.28619;
  return D.28613;
}


mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  long unsigned int D.28621;
  long unsigned int D.28622;
  struct MonoMemPool * D.28629;
  long int D.28630;
  struct MonoInst * D.28631;
  guint16 iftmp.59;
  int D.28636;
  int D.28637;
  const unsigned char * D.28638;
  long int D.28641;
  struct MonoInst * D.28642;
  int D.28643;
  int D.28644;
  long int D.28645;
  struct MonoInst * D.28646;
  int D.28647;
  void * D.28649;
  unsigned int D.28650;
  int D.28651;
  long int D.28653;
  void * D.28654;
  unsigned int D.28655;
  int D.28656;
  struct MonoBasicBlock * D.28657;
  struct MonoInst * D.28658;
  long int D.28662;
  struct MonoInst * D.28663;
  int D.28664;
  int D.28665;
  unsigned int D.28666;
  int D.28667;
  int D.28668;
  struct MonoInst * D.28669;
  int D.28670;

  D.28621 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28622 = D.28621 & 274877906944;
  if (D.28622 != 0) goto <D.28623>; else goto <D.28624>;
  <D.28623>:
  if (0 != 0) goto <D.28625>; else goto <D.28626>;
  <D.28625>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.28621 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28622 = D.28621 & 274877906944;
    if (D.28622 != 0) goto <D.28627>; else goto <D.28628>;
    <D.28627>:
    D.28629 = cfg->mempool;
    c = mono_mempool_alloc (D.28629, 80);
    c->data.op[1].const_val = 0;
    D.28630 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.28630;
    c->prev = 0B;
    D.28631 = c->prev;
    c->next = D.28631;
    D.28621 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28622 = D.28621 & 274877906944;
    if (D.28622 != 0) goto <D.28633>; else goto <D.28634>;
    <D.28633>:
    iftmp.59 = 734;
    goto <D.28635>;
    <D.28634>:
    iftmp.59 = 363;
    <D.28635>:
    c->opcode = iftmp.59;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.28636 = c->sreg3;
    c->sreg2 = D.28636;
    D.28637 = c->sreg2;
    c->sreg1 = D.28637;
    D.28638 = cfg->ip;
    c->cil_code = D.28638;
    D.28621 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28622 = D.28621 & 274877906944;
    if (D.28622 != 0) goto <D.28639>; else goto <D.28640>;
    <D.28639>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.28629 = cfg->mempool;
      group = mono_mempool_alloc (D.28629, 80);
      group->data.op[1].const_val = 0;
      D.28641 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.28641;
      group->prev = 0B;
      D.28642 = group->prev;
      group->next = D.28642;
      group->opcode = 733;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.28643 = group->sreg3;
      group->sreg2 = D.28643;
      D.28644 = group->sreg2;
      group->sreg1 = D.28644;
      D.28638 = cfg->ip;
      group->cil_code = D.28638;
      D.28645 = (long int) key;
      D.28646 = (struct MonoInst *) D.28645;
      group->data.op[0].src = D.28646;
      group->data.op[1].src = 48B;
      D.28647 = got_loc->dreg;
      c->sreg1 = D.28647;
      c->data.op[1].p = group;
    }
    goto <D.28648>;
    <D.28640>:
    D.28645 = (long int) key;
    D.28649 = (void *) D.28645;
    c->data.op[0].p = D.28649;
    c->data.op[1].src = 48B;
    <D.28648>:
    c->type = 3;
    D.28650 = alloc_dreg (cfg, 3);
    D.28651 = (int) D.28650;
    c->dreg = D.28651;
    goto <D.28652>;
    <D.28628>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.28629 = cfg->mempool;
      c = mono_mempool_alloc (D.28629, 80);
      c->data.op[1].const_val = 0;
      D.28630 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.28630;
      c->prev = 0B;
      D.28631 = c->prev;
      c->next = D.28631;
      c->opcode = 363;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.28636 = c->sreg3;
      c->sreg2 = D.28636;
      D.28637 = c->sreg2;
      c->sreg1 = D.28637;
      D.28638 = cfg->ip;
      c->cil_code = D.28638;
      D.28653 = (long int) _offset;
      D.28654 = (void *) D.28653;
      c->data.op[0].p = D.28654;
      c->type = 3;
      D.28655 = alloc_dreg (cfg, 3);
      D.28656 = (int) D.28655;
      c->dreg = D.28656;
    }
    <D.28652>:
    D.28657 = cfg->cbb;
    D.28658 = D.28657->last_ins;
    if (D.28658 != 0B) goto <D.28659>; else goto <D.28660>;
    <D.28659>:
    D.28657 = cfg->cbb;
    D.28658 = D.28657->last_ins;
    D.28658->next = c;
    D.28657 = cfg->cbb;
    D.28658 = D.28657->last_ins;
    c->prev = D.28658;
    D.28657 = cfg->cbb;
    D.28657->last_ins = c;
    goto <D.28661>;
    <D.28660>:
    D.28657 = cfg->cbb;
    D.28657 = cfg->cbb;
    D.28657->last_ins = c;
    D.28658 = D.28657->last_ins;
    D.28657->code = D.28658;
    <D.28661>:
    D.28629 = cfg->mempool;
    ins = mono_mempool_alloc (D.28629, 80);
    ins->data.op[1].const_val = 0;
    D.28662 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.28662;
    ins->prev = 0B;
    D.28663 = ins->prev;
    ins->next = D.28663;
    ins->opcode = 792;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.28664 = ins->sreg3;
    ins->sreg2 = D.28664;
    D.28665 = ins->sreg2;
    ins->sreg1 = D.28665;
    D.28638 = cfg->ip;
    ins->cil_code = D.28638;
    D.28666 = mono_alloc_preg (cfg);
    D.28667 = (int) D.28666;
    ins->dreg = D.28667;
    D.28668 = c->dreg;
    ins->sreg1 = D.28668;
    D.28669 = ins;
    return D.28669;
  }
  <D.28626>:
  D.28669 = 0B;
  return D.28669;
  <D.28624>:
  D.28670 = mini_get_tls_offset (key);
  D.28669 = mono_create_tls_get_offset (cfg, D.28670);
  return D.28669;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.28674;
  struct MonoMemPool * D.28677;
  long int D.28678;
  struct MonoInst * D.28679;
  int D.28680;
  int D.28681;
  const unsigned char * D.28682;
  unsigned int D.28683;
  int D.28684;
  long int D.28685;
  struct MonoInst * ins;

  if (0 != 0) goto <D.28672>; else goto <D.28673>;
  <D.28672>:
  D.28674 = 0B;
  return D.28674;
  <D.28673>:
  if (offset == -1) goto <D.28675>; else goto <D.28676>;
  <D.28675>:
  D.28674 = 0B;
  return D.28674;
  <D.28676>:
  D.28677 = cfg->mempool;
  ins = mono_mempool_alloc (D.28677, 80);
  ins->data.op[1].const_val = 0;
  D.28678 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.28678;
  ins->prev = 0B;
  D.28679 = ins->prev;
  ins->next = D.28679;
  ins->opcode = 791;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28680 = ins->sreg3;
  ins->sreg2 = D.28680;
  D.28681 = ins->sreg2;
  ins->sreg1 = D.28681;
  D.28682 = cfg->ip;
  ins->cil_code = D.28682;
  D.28683 = mono_alloc_preg (cfg);
  D.28684 = (int) D.28683;
  ins->dreg = D.28684;
  D.28685 = (long int) offset;
  ins->data.op[0].const_val = D.28685;
  D.28674 = ins;
  return D.28674;
}


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.28703;
  int D.28704;
  struct MonoJumpInfo * D.28707;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.25900>;
  <D.25899>:
  D.28703 = *ji;
  D.28704 = D.28703->ip.i;
  if (D.28704 == ip) goto <D.28705>; else goto <D.28706>;
  <D.28705>:
  D.28703 = *ji;
  D.28707 = D.28703->next;
  *ji = D.28707;
  goto <D.28708>;
  <D.28706>:
  D.28703 = *ji;
  ji = &D.28703->next;
  <D.28708>:
  <D.25900>:
  D.28703 = *ji;
  if (D.28703 != 0B) goto <D.25899>; else goto <D.25901>;
  <D.25901>:
}


mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.28709;
  void * D.28710;
  struct MonoJumpInfoToken * D.28711;
  struct MonoJumpInfoToken * D.28712;
  void * D.28713;
  struct MonoJumpInfoBBTable * D.28714;
  struct MonoJumpInfoBBTable * D.28715;
  int D.28716;
  long unsigned int D.28717;
  unsigned int D.28718;
  unsigned int D.28719;
  void * D.28720;
  struct MonoBasicBlock * * D.28721;
  struct MonoBasicBlock * * D.28722;
  long unsigned int D.28723;
  void * D.28724;
  struct MonoJumpInfoRgctxEntry * D.28725;
  struct MonoJumpInfoRgctxEntry * D.28726;
  struct MonoJumpInfo * D.28727;
  struct MonoJumpInfo * D.28728;
  void * D.28729;
  struct MonoJumpInfoGSharedVtCall * D.28730;
  struct MonoJumpInfoGSharedVtCall * D.28731;
  struct GPtrArray * D.28732;
  struct GPtrArray * D.28733;
  void * * D.28736;
  long unsigned int D.28737;
  long unsigned int D.28738;
  void * * D.28739;
  struct GPtrArray * D.28740;
  unsigned int i.60;
  unsigned int D.28742;
  struct MonoJumpInfo * D.28743;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 40);
  memcpy (res, patch_info, 40);
  D.28709 = patch_info->type;
  switch (D.28709) <default: <D.25925>, case 8: <D.25913>, case 17: <D.25908>, case 18: <D.25910>, case 19: <D.25909>, case 28: <D.25911>, case 29: <D.25907>, case 35: <D.25914>, case 45: <D.25915>, case 46: <D.25916>>
  <D.25907>:
  <D.25908>:
  <D.25909>:
  <D.25910>:
  <D.25911>:
  D.28710 = mono_mempool_alloc (mp, 32);
  res->data.token = D.28710;
  D.28711 = res->data.token;
  D.28712 = patch_info->data.token;
  memcpy (D.28711, D.28712, 32);
  goto <D.25912>;
  <D.25913>:
  D.28713 = mono_mempool_alloc (mp, 16);
  res->data.table = D.28713;
  D.28714 = res->data.table;
  D.28715 = patch_info->data.table;
  memcpy (D.28714, D.28715, 16);
  D.28714 = res->data.table;
  D.28715 = patch_info->data.table;
  D.28716 = D.28715->table_size;
  D.28717 = (long unsigned int) D.28716;
  D.28718 = (unsigned int) D.28717;
  D.28719 = D.28718 * 8;
  D.28720 = mono_mempool_alloc (mp, D.28719);
  D.28714->table = D.28720;
  D.28714 = res->data.table;
  D.28721 = D.28714->table;
  D.28715 = patch_info->data.table;
  D.28722 = D.28715->table;
  D.28715 = patch_info->data.table;
  D.28716 = D.28715->table_size;
  D.28717 = (long unsigned int) D.28716;
  D.28723 = D.28717 * 8;
  memcpy (D.28721, D.28722, D.28723);
  goto <D.25912>;
  <D.25914>:
  D.28724 = mono_mempool_alloc (mp, 32);
  res->data.rgctx_entry = D.28724;
  D.28725 = res->data.rgctx_entry;
  D.28726 = patch_info->data.rgctx_entry;
  memcpy (D.28725, D.28726, 32);
  D.28725 = res->data.rgctx_entry;
  D.28725 = res->data.rgctx_entry;
  D.28727 = D.28725->data;
  D.28728 = mono_patch_info_dup_mp (mp, D.28727);
  D.28725->data = D.28728;
  goto <D.25912>;
  <D.25915>:
  D.28729 = mono_mempool_alloc (mp, 16);
  res->data.gsharedvt = D.28729;
  D.28730 = res->data.gsharedvt;
  D.28731 = patch_info->data.gsharedvt;
  memcpy (D.28730, D.28731, 16);
  goto <D.25912>;
  <D.25916>:
  {
    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.28732 = monoeg_g_ptr_array_new ();
    info->entries = D.28732;
    D.28733 = oinfo->entries;
    if (D.28733 != 0B) goto <D.28734>; else goto <D.28735>;
    <D.28734>:
    i = 0;
    goto <D.25923>;
    <D.25922>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.28733 = oinfo->entries;
      D.28736 = D.28733->pdata;
      D.28737 = (long unsigned int) i;
      D.28738 = D.28737 * 8;
      D.28739 = D.28736 + D.28738;
      otemplate = *D.28739;
      template = mono_mempool_alloc0 (mp, 24);
      memcpy (template, otemplate, 24);
      D.28740 = info->entries;
      monoeg_g_ptr_array_add (D.28740, template);
    }
    i = i + 1;
    <D.25923>:
    i.60 = (unsigned int) i;
    D.28733 = oinfo->entries;
    D.28742 = D.28733->len;
    if (i.60 < D.28742) goto <D.25922>; else goto <D.25924>;
    <D.25924>:
    <D.28735>:
    goto <D.25912>;
  }
  <D.25925>:
  goto <D.25912>;
  <D.25912>:
  D.28743 = res;
  return D.28743;
}


mono_patch_info_hash (const void * data)
{
  <unnamed type> D.28746;
  guint D.28747;
  unsigned int D.28748;
  struct MonoJumpInfoToken * D.28749;
  unsigned int D.28750;
  unsigned int D.28751;
  guint iftmp.61;
  int D.28753;
  struct MonoGenericInst * D.28756;
  long int D.28757;
  const char * D.28759;
  unsigned int D.28760;
  signed int D.28761;
  const void * D.28762;
  long int D.28763;
  signed int D.28764;
  signed int D.28765;
  struct MonoJumpInfoGSharedVtCall * D.28766;
  struct MonoMethod * D.28767;
  long int D.28768;
  signed int D.28769;
  signed int D.28770;
  struct MonoMethod * D.28771;
  long int D.28772;
  signed int D.28773;
  signed int D.28774;
  int D.28775;
  signed int D.28776;
  <unnamed type> D.28777;
  signed int D.28778;
  signed int D.28779;
  struct MonoJumpInfo * D.28780;
  unsigned int D.28781;
  signed int D.28782;
  signed int D.28783;
  struct MonoJumpInfoBBTable * D.28784;
  int D.28785;
  unsigned int D.28786;
  struct MonoGSharedVtMethodInfo * D.28787;
  struct MonoMethod * D.28788;
  long int D.28789;
  signed int D.28790;
  signed int D.28791;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.28746 = ji->type;
  switch (D.28746) <default: <D.25970>, case 3: <D.25943>, case 4: <D.25944>, case 6: <D.25942>, case 7: <D.25935>, case 8: <D.25967>, case 11: <D.25937>, case 12: <D.25945>, case 13: <D.25948>, case 14: <D.25936>, case 15: <D.25940>, case 16: <D.25949>, case 17: <D.25931>, case 18: <D.25932>, case 19: <D.25934>, case 23: <D.25938>, case 24: <D.25939>, case 27: <D.25966>, case 28: <D.25933>, case 29: <D.25930>, case 30: <D.25952>, case 31: <D.25947>, case 32: <D.25946>, case 33: <D.25959>, case 34: <D.25951>, case 35: <D.25957>, case 36: <D.25941>, case 37: <D.25963>, case 38: <D.25964>, case 39: <D.25960>, case 40: <D.25950>, case 42: <D.25961>, case 43: <D.25965>, case 44: <D.25953>, case 45: <D.25956>, case 46: <D.25968>, case 47: <D.25962>, case 48: <D.25954>, case 49: <D.25969>, case 50: <D.25955>>
  <D.25930>:
  <D.25931>:
  <D.25932>:
  <D.25933>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28749 = ji->data.token;
  D.28750 = D.28749->token;
  D.28747 = D.28748 | D.28750;
  return D.28747;
  <D.25934>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28749 = ji->data.token;
  D.28750 = D.28749->token;
  D.28751 = D.28748 | D.28750;
  D.28749 = ji->data.token;
  D.28753 = D.28749->has_context;
  if (D.28753 != 0) goto <D.28754>; else goto <D.28755>;
  <D.28754>:
  D.28749 = ji->data.token;
  D.28756 = D.28749->context.class_inst;
  D.28757 = (long int) D.28756;
  iftmp.61 = (guint) D.28757;
  goto <D.28758>;
  <D.28755>:
  iftmp.61 = 0;
  <D.28758>:
  D.28747 = D.28751 | iftmp.61;
  return D.28747;
  <D.25935>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28759 = ji->data.name;
  D.28760 = monoeg_g_str_hash (D.28759);
  D.28747 = D.28748 | D.28760;
  return D.28747;
  <D.25936>:
  <D.25937>:
  <D.25938>:
  <D.25939>:
  <D.25940>:
  <D.25941>:
  <D.25942>:
  <D.25943>:
  <D.25944>:
  <D.25945>:
  <D.25946>:
  <D.25947>:
  <D.25948>:
  <D.25949>:
  <D.25950>:
  <D.25951>:
  <D.25952>:
  <D.25953>:
  <D.25954>:
  <D.25955>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28761 = (signed int) D.28748;
  D.28762 = ji->data.target;
  D.28763 = (long int) D.28762;
  D.28764 = (signed int) D.28763;
  D.28765 = D.28761 | D.28764;
  D.28747 = (guint) D.28765;
  return D.28747;
  <D.25956>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28761 = (signed int) D.28748;
  D.28766 = ji->data.gsharedvt;
  D.28767 = D.28766->method;
  D.28768 = (long int) D.28767;
  D.28769 = (signed int) D.28768;
  D.28770 = D.28761 | D.28769;
  D.28747 = (guint) D.28770;
  return D.28747;
  <D.25957>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.28746 = ji->type;
    D.28748 = D.28746 << 8;
    D.28761 = (signed int) D.28748;
    D.28771 = e->method;
    D.28772 = (long int) D.28771;
    D.28773 = (signed int) D.28772;
    D.28774 = D.28761 | D.28773;
    D.28775 = e->in_mrgctx;
    D.28776 = D.28774 | D.28775;
    D.28777 = e->info_type;
    D.28778 = (signed int) D.28777;
    D.28779 = D.28776 | D.28778;
    D.28780 = e->data;
    D.28781 = mono_patch_info_hash (D.28780);
    D.28782 = (signed int) D.28781;
    D.28783 = D.28779 | D.28782;
    D.28747 = (guint) D.28783;
    return D.28747;
  }
  <D.25959>:
  <D.25960>:
  <D.25961>:
  <D.25962>:
  <D.25963>:
  <D.25964>:
  <D.25965>:
  <D.25966>:
  D.28746 = ji->type;
  D.28747 = D.28746 << 8;
  return D.28747;
  <D.25967>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28784 = ji->data.table;
  D.28785 = D.28784->table_size;
  D.28786 = (unsigned int) D.28785;
  D.28747 = D.28748 | D.28786;
  return D.28747;
  <D.25968>:
  D.28746 = ji->type;
  D.28748 = D.28746 << 8;
  D.28761 = (signed int) D.28748;
  D.28787 = ji->data.gsharedvt_method;
  D.28788 = D.28787->method;
  D.28789 = (long int) D.28788;
  D.28790 = (signed int) D.28789;
  D.28791 = D.28761 | D.28790;
  D.28747 = (guint) D.28791;
  return D.28747;
  <D.25969>:
  D.28762 = ji->data.target;
  D.28747 = monoeg_g_str_hash (D.28762);
  return D.28747;
  <D.25970>:
  D.28746 = ji->type;
  printf ("info type: %d\n", D.28746);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.28747 = 0;
  return D.28747;
}


mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.28793;
  <unnamed type> D.28794;
  gint D.28797;
  struct MonoJumpInfoToken * D.28800;
  struct MonoImage * D.28801;
  struct MonoJumpInfoToken * D.28802;
  struct MonoImage * D.28803;
  long unsigned int D.28805;
  long unsigned int D.28806;
  long unsigned int D.28807;
  long unsigned int D.28808;
  struct MonoGenericInst * D.28810;
  struct MonoGenericInst * D.28811;
  struct MonoGenericInst * D.28813;
  struct MonoGenericInst * D.28814;
  const char * D.28815;
  const char * D.28816;
  int iftmp.62;
  struct MonoMethod * D.28820;
  struct MonoMethod * D.28821;
  int D.28823;
  int D.28824;
  <unnamed type> D.28826;
  <unnamed type> D.28827;
  struct MonoJumpInfo * D.28829;
  struct MonoJumpInfo * D.28830;
  int D.28831;
  int iftmp.63;
  struct MonoMethodSignature * D.28836;
  struct MonoMethodSignature * D.28837;
  struct MonoMethod * D.28839;
  struct MonoMethod * D.28840;
  struct MonoGSharedVtMethodInfo * D.28842;
  struct MonoMethod * D.28843;
  struct MonoGSharedVtMethodInfo * D.28844;
  struct MonoMethod * D.28845;
  _Bool D.28846;
  const void * D.28847;
  const void * D.28848;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.28793 = ji1->type;
  D.28794 = ji2->type;
  if (D.28793 != D.28794) goto <D.28795>; else goto <D.28796>;
  <D.28795>:
  D.28797 = 0;
  return D.28797;
  <D.28796>:
  D.28793 = ji1->type;
  switch (D.28793) <default: <D.25991>, case 7: <D.25983>, case 17: <D.25978>, case 18: <D.25980>, case 19: <D.25979>, case 28: <D.25981>, case 29: <D.25977>, case 35: <D.25984>, case 45: <D.25987>, case 46: <D.25990>>
  <D.25977>:
  <D.25978>:
  <D.25979>:
  <D.25980>:
  <D.25981>:
  D.28800 = ji1->data.token;
  D.28801 = D.28800->image;
  D.28802 = ji2->data.token;
  D.28803 = D.28802->image;
  if (D.28801 != D.28803) goto <D.28798>; else goto <D.28804>;
  <D.28804>:
  D.28800 = ji1->data.token;
  D.28805 = BIT_FIELD_REF <*D.28800, 64, 64>;
  D.28806 = D.28805;
  D.28802 = ji2->data.token;
  D.28807 = BIT_FIELD_REF <*D.28802, 64, 64>;
  D.28808 = D.28807;
  if (D.28806 != D.28808) goto <D.28798>; else goto <D.28809>;
  <D.28809>:
  D.28800 = ji1->data.token;
  D.28810 = D.28800->context.class_inst;
  D.28802 = ji2->data.token;
  D.28811 = D.28802->context.class_inst;
  if (D.28810 != D.28811) goto <D.28798>; else goto <D.28812>;
  <D.28812>:
  D.28800 = ji1->data.token;
  D.28813 = D.28800->context.method_inst;
  D.28802 = ji2->data.token;
  D.28814 = D.28802->context.method_inst;
  if (D.28813 != D.28814) goto <D.28798>; else goto <D.28799>;
  <D.28798>:
  D.28797 = 0;
  return D.28797;
  <D.28799>:
  goto <D.25982>;
  <D.25983>:
  D.28815 = ji1->data.name;
  D.28816 = ji2->data.name;
  D.28797 = monoeg_g_str_equal (D.28815, D.28816);
  return D.28797;
  <D.25984>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.28820 = e1->method;
    D.28821 = e2->method;
    if (D.28820 == D.28821) goto <D.28822>; else goto <D.28818>;
    <D.28822>:
    D.28823 = e1->in_mrgctx;
    D.28824 = e2->in_mrgctx;
    if (D.28823 == D.28824) goto <D.28825>; else goto <D.28818>;
    <D.28825>:
    D.28826 = e1->info_type;
    D.28827 = e2->info_type;
    if (D.28826 == D.28827) goto <D.28828>; else goto <D.28818>;
    <D.28828>:
    D.28829 = e1->data;
    D.28830 = e2->data;
    D.28831 = mono_patch_info_equal (D.28829, D.28830);
    if (D.28831 != 0) goto <D.28832>; else goto <D.28818>;
    <D.28832>:
    iftmp.62 = 1;
    goto <D.28819>;
    <D.28818>:
    iftmp.62 = 0;
    <D.28819>:
    D.28797 = iftmp.62;
    return D.28797;
  }
  <D.25987>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.28836 = c1->sig;
    D.28837 = c2->sig;
    if (D.28836 == D.28837) goto <D.28838>; else goto <D.28834>;
    <D.28838>:
    D.28839 = c1->method;
    D.28840 = c2->method;
    if (D.28839 == D.28840) goto <D.28841>; else goto <D.28834>;
    <D.28841>:
    iftmp.63 = 1;
    goto <D.28835>;
    <D.28834>:
    iftmp.63 = 0;
    <D.28835>:
    D.28797 = iftmp.63;
    return D.28797;
  }
  <D.25990>:
  D.28842 = ji1->data.gsharedvt_method;
  D.28843 = D.28842->method;
  D.28844 = ji2->data.gsharedvt_method;
  D.28845 = D.28844->method;
  D.28846 = D.28843 == D.28845;
  D.28797 = (gint) D.28846;
  return D.28797;
  <D.25991>:
  D.28847 = ji1->data.target;
  D.28848 = ji2->data.target;
  if (D.28847 != D.28848) goto <D.28849>; else goto <D.28850>;
  <D.28849>:
  D.28797 = 0;
  return D.28797;
  <D.28850>:
  goto <D.25982>;
  <D.25982>:
  D.28797 = 1;
  return D.28797;
}


mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.28852;
  sizetype D.28853;
  <unnamed type> D.28854;
  struct MonoBasicBlock * D.28855;
  int D.28856;
  sizetype D.28857;
  struct MonoInst * D.28858;
  long int D.28859;
  sizetype D.28860;
  long int D.28861;
  sizetype D.28862;
  const char * D.28863;
  struct MonoMethod * D.28868;
  union mono_mutex_t * D.28872;
  _Bool D.28875;
  long int D.28876;
  long int D.28877;
  void * D.28880;
  struct GHashTable * D.28881;
  struct GHashTable * D.28884;
  _Bool D.28889;
  long int D.28890;
  long int D.28891;
  long unsigned int D.28897;
  long unsigned int D.28898;
  struct MonoJitDynamicMethodInfo * D.28900;
  struct MonoCodeManager * D.28901;
  struct MonoJumpInfoBBTable * D.28902;
  int D.28903;
  unsigned int D.28904;
  unsigned int D.28905;
  int D.28906;
  int mono_aot_only.64;
  long unsigned int D.28910;
  unsigned int D.28911;
  unsigned int D.28912;
  long unsigned int D.28914;
  long unsigned int D.28915;
  void * * D.28916;
  struct MonoBasicBlock * * D.28917;
  struct MonoBasicBlock * * D.28918;
  struct MonoBasicBlock * D.28919;
  long int D.28920;
  int D.28921;
  sizetype D.28922;
  void * D.28923;
  struct MonoClass * D.28924;
  short unsigned int D.28925;
  long int D.28926;
  int D.28927;
  int D.28928;
  int D.28929;
  long int D.28930;
  _Bool D.28931;
  long int D.28932;
  long int D.28933;
  _Bool D.28936;
  long int D.28937;
  long int D.28938;
  struct MonoClassField * D.28941;
  struct MonoClass * D.28942;
  int D.28943;
  _Bool D.28948;
  long int D.28949;
  long int D.28950;
  struct GHashTable * D.28953;
  _Bool D.28958;
  long int D.28959;
  long int D.28960;
  _Bool D.28963;
  long int D.28964;
  long int D.28965;
  void * D.28968;
  _Bool D.28969;
  long int D.28970;
  long int D.28971;
  long unsigned int D.28976;
  long unsigned int D.28977;
  struct MonoClass * D.28979;
  unsigned int D.28980;
  unsigned int D.28981;
  int D.28984;
  void * D.28988;
  int D.28989;
  sizetype D.28990;
  struct MonoJumpInfoToken * D.28991;
  unsigned int D.28992;
  struct MonoImage * D.28993;
  unsigned int D.28994;
  unsigned int rva.65;
  unsigned int D.28996;
  struct MonoGenericContext * iftmp.66;
  int D.28998;
  struct MonoClass * handle_class.67;
  struct MonoClass * D.29003;
  struct MonoGenericContext * iftmp.68;
  struct MonoClass * handle_class.69;
  const char * D.29009;
  short unsigned int D.29010;
  int D.29011;
  int D.29012;
  struct MonoImage * D.29021;
  const char * exc_class.70;
  const char * exc_arg.71;
  struct MonoException * D.29024;
  char * D.29025;
  char * D.29032;
  struct MonoClass * D.29033;
  _Bool D.29034;
  long int D.29035;
  long int D.29036;
  struct MonoGenericContext * D.29039;
  struct MonoGenericInst * D.29040;
  struct MonoJumpInfo * D.29041;
  <unnamed type> D.29042;
  struct MonoMethod * D.29043;
  int D.29044;
  struct MonoClass * D.29045;
  struct MonoType * D.29046;
  <unnamed type> D.29047;
  struct MonoGenericContext * D.29048;
  struct MonoMethod * D.29049;
  struct MonoGenericContext * D.29050;
  struct MonoClassField * D.29051;
  struct MonoGenericContext * D.29052;
  struct MonoMethodSignature * D.29053;
  struct MonoGenericContext * D.29054;
  struct MonoJumpInfoGSharedVtCall * D.29055;
  struct MonoGenericContext * D.29056;
  struct MonoMethod * D.29057;
  struct GPtrArray * D.29058;
  struct GPtrArray * D.29059;
  void * * D.29060;
  long unsigned int D.29061;
  long unsigned int D.29062;
  void * * D.29063;
  struct GPtrArray * D.29064;
  unsigned int i.72;
  unsigned int D.29066;
  struct MonoGenericContext * D.29067;
  unsigned int mono_jit_tls_id.73;
  long unsigned int D.29072;
  const void * D.29073;
  long int D.29074;
  <unnamed type> D.29075;
  long int D.29076;
  unsigned char * ip;
  const void * target;

  D.28852 = patch_info->ip.i;
  D.28853 = (sizetype) D.28852;
  ip = code + D.28853;
  target = 0B;
  D.28854 = patch_info->type;
  switch (D.28854) <default: <D.26099>, case 0: <D.26001>, case 1: <D.26003>, case 2: <D.26004>, case 3: <D.26012>, case 4: <D.26011>, case 5: <D.26006>, case 6: <D.26023>, case 7: <D.26007>, case 8: <D.26017>, case 10: <D.26044>, case 11: <D.26024>, case 12: <D.26025>, case 13: <D.26026>, case 14: <D.26030>, case 15: <D.26031>, case 16: <D.26034>, case 17: <D.26045>, case 18: <D.26049>, case 19: <D.26046>, case 20: <D.26042>, case 21: <D.26043>, case 22: <D.26005>, case 23: <D.26028>, case 24: <D.26029>, case 25: <D.26061>, case 26: <D.26062>, case 27: <D.26063>, case 28: <D.26052>, case 29: <D.26039>, case 30: <D.26033>, case 31: <D.26053>, case 32: <D.26009>, case 33: <D.26058>, case 34: <D.26059>, case 35: <D.26065>, case 36: <D.26086>, case 37: <D.26087>, case 38: <D.26088>, case 40: <D.26089>, case 41: <D.26090>, case 42: <D.26091>, case 43: <D.26094>, case 44: <D.26027>, case 47: <D.26095>, case 48: <D.26096>, case 49: <D.26098>, case 50: <D.26013>, case 51: <D.26064>>
  <D.26001>:
  D.28855 = patch_info->data.bb;
  D.28856 = D.28855->native_offset;
  D.28857 = (sizetype) D.28856;
  target = code + D.28857;
  goto <D.26002>;
  <D.26003>:
  target = patch_info->data.target;
  goto <D.26002>;
  <D.26004>:
  D.28858 = patch_info->data.inst;
  D.28859 = D.28858->data.op[0].const_val;
  D.28860 = (sizetype) D.28859;
  target = code + D.28860;
  goto <D.26002>;
  <D.26005>:
  target = ip;
  goto <D.26002>;
  <D.26006>:
  D.28861 = patch_info->data.offset;
  D.28862 = (sizetype) D.28861;
  target = code + D.28862;
  goto <D.26002>;
  <D.26007>:
  {
    struct MonoJitICallInfo * mi;

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

    D.28863 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.28863);
    if (mi == 0B) goto <D.28866>; else goto <D.28867>;
    <D.28866>:
    D.28863 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.28863);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.28867>:
    target = mi->func;
    goto <D.26002>;
  }
  <D.26011>:
  D.28868 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.28868, 0);
  goto <D.26002>;
  <D.26012>:
  D.28868 = patch_info->data.method;
  if (D.28868 == method) goto <D.28869>; else goto <D.28870>;
  <D.28869>:
  target = code;
  goto <D.28871>;
  <D.28870>:
  D.28868 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.28868);
  <D.28871>:
  goto <D.26002>;
  <D.26013>:
  {
    void * code_slot;

    {
      int ret;

      D.28872 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.28872);
      if (ret != 0) goto <D.28873>; else goto <D.28874>;
      <D.28873>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.28874>:
      D.28875 = ret != 0;
      D.28876 = (long int) D.28875;
      D.28877 = __builtin_expect (D.28876, 0);
      if (D.28877 != 0) goto <D.28878>; else goto <D.28879>;
      <D.28878>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.28879>:
    }
    D.28880 = domain->runtime_info;
    D.28881 = MEM[(struct MonoJitDomainInfo *)D.28880].method_code_hash;
    if (D.28881 == 0B) goto <D.28882>; else goto <D.28883>;
    <D.28882>:
    D.28880 = domain->runtime_info;
    D.28884 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.28880].method_code_hash = D.28884;
    <D.28883>:
    D.28880 = domain->runtime_info;
    D.28881 = MEM[(struct MonoJitDomainInfo *)D.28880].method_code_hash;
    D.28868 = patch_info->data.method;
    code_slot = monoeg_g_hash_table_lookup (D.28881, D.28868);
    if (code_slot == 0B) goto <D.28885>; else goto <D.28886>;
    <D.28885>:
    code_slot = mono_domain_alloc0 (domain, 8);
    D.28880 = domain->runtime_info;
    D.28881 = MEM[(struct MonoJitDomainInfo *)D.28880].method_code_hash;
    D.28868 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.28881, D.28868, code_slot, 0);
    <D.28886>:
    {
      int ret;

      D.28872 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.28872);
      if (ret != 0) goto <D.28887>; else goto <D.28888>;
      <D.28887>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.28888>:
      D.28889 = ret != 0;
      D.28890 = (long int) D.28889;
      D.28891 = __builtin_expect (D.28890, 0);
      if (D.28891 != 0) goto <D.28892>; else goto <D.28893>;
      <D.28892>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.28893>:
    }
    target = code_slot;
    goto <D.26002>;
  }
  <D.26017>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.28896>; else goto <D.28894>;
    <D.28896>:
    D.28897 = BIT_FIELD_REF <*method, 64, 256>;
    D.28898 = D.28897 & 512;
    if (D.28898 != 0) goto <D.28899>; else goto <D.28894>;
    <D.28899>:
    D.28900 = mono_dynamic_code_hash_lookup (domain, method);
    D.28901 = D.28900->code_mp;
    D.28902 = patch_info->data.table;
    D.28903 = D.28902->table_size;
    D.28904 = (unsigned int) D.28903;
    D.28905 = D.28904 * 8;
    D.28906 = (int) D.28905;
    jump_table = mono_code_manager_reserve (D.28901, D.28906);
    goto <D.28895>;
    <D.28894>:
    mono_aot_only.64 = mono_aot_only;
    if (mono_aot_only.64 != 0) goto <D.28908>; else goto <D.28909>;
    <D.28908>:
    D.28902 = patch_info->data.table;
    D.28903 = D.28902->table_size;
    D.28910 = (long unsigned int) D.28903;
    D.28911 = (unsigned int) D.28910;
    D.28912 = D.28911 * 8;
    jump_table = mono_domain_alloc (domain, D.28912);
    goto <D.28913>;
    <D.28909>:
    D.28902 = patch_info->data.table;
    D.28903 = D.28902->table_size;
    D.28904 = (unsigned int) D.28903;
    D.28905 = D.28904 * 8;
    D.28906 = (int) D.28905;
    jump_table = mono_domain_code_reserve (domain, D.28906);
    <D.28913>:
    <D.28895>:
    i = 0;
    goto <D.26021>;
    <D.26020>:
    D.28914 = (long unsigned int) i;
    D.28915 = D.28914 * 8;
    D.28916 = jump_table + D.28915;
    D.28902 = patch_info->data.table;
    D.28917 = D.28902->table;
    D.28914 = (long unsigned int) i;
    D.28915 = D.28914 * 8;
    D.28918 = D.28917 + D.28915;
    D.28919 = *D.28918;
    D.28920 = (long int) D.28919;
    D.28921 = (int) D.28920;
    D.28922 = (sizetype) D.28921;
    D.28923 = code + D.28922;
    *D.28916 = D.28923;
    i = i + 1;
    <D.26021>:
    D.28902 = patch_info->data.table;
    D.28903 = D.28902->table_size;
    if (D.28903 > i) goto <D.26020>; else goto <D.26022>;
    <D.26022>:
    target = jump_table;
    goto <D.26002>;
  }
  <D.26023>:
  <D.26024>:
  <D.26025>:
  <D.26026>:
  <D.26027>:
  target = patch_info->data.target;
  goto <D.26002>;
  <D.26028>:
  D.28924 = patch_info->data.klass;
  mono_class_init (D.28924);
  D.28924 = patch_info->data.klass;
  D.28925 = D.28924->interface_id;
  D.28926 = (long int) D.28925;
  target = (const void *) D.28926;
  goto <D.26002>;
  <D.26029>:
  D.28924 = patch_info->data.klass;
  mono_class_init (D.28924);
  D.28924 = patch_info->data.klass;
  D.28925 = D.28924->interface_id;
  D.28927 = (int) D.28925;
  D.28928 = ~D.28927;
  D.28929 = D.28928 * 8;
  D.28930 = (long int) D.28929;
  target = (const void *) D.28930;
  goto <D.26002>;
  <D.26030>:
  D.28924 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.28924);
  D.28931 = target == 0B;
  D.28932 = (long int) D.28931;
  D.28933 = __builtin_expect (D.28932, 0);
  if (D.28933 != 0) goto <D.28934>; else goto <D.28935>;
  <D.28934>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.28935>:
  goto <D.26002>;
  <D.26031>:
  {
    struct MonoVTable * vtable;

    D.28924 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.28924);
    D.28936 = vtable == 0B;
    D.28937 = (long int) D.28936;
    D.28938 = __builtin_expect (D.28937, 0);
    if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
    <D.28939>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.28940>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.26002>;
  }
  <D.26033>:
  D.28924 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.28924);
  goto <D.26002>;
  <D.26034>:
  {
    struct MonoVTable * vtable;

    D.28941 = patch_info->data.field;
    D.28942 = D.28941->parent;
    vtable = mono_class_vtable (domain, D.28942);
    D.28941 = patch_info->data.field;
    D.28943 = mono_class_field_is_special_static (D.28941);
    if (D.28943 != 0) goto <D.28944>; else goto <D.28945>;
    <D.28944>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.28872 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.28872);
        if (ret != 0) goto <D.28946>; else goto <D.28947>;
        <D.28946>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28947>:
        D.28948 = ret != 0;
        D.28949 = (long int) D.28948;
        D.28950 = __builtin_expect (D.28949, 0);
        if (D.28950 != 0) goto <D.28951>; else goto <D.28952>;
        <D.28951>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.28952>:
      }
      D.28953 = domain->special_static_fields;
      if (D.28953 != 0B) goto <D.28954>; else goto <D.28955>;
      <D.28954>:
      D.28953 = domain->special_static_fields;
      D.28941 = patch_info->data.field;
      addr = monoeg_g_hash_table_lookup (D.28953, D.28941);
      <D.28955>:
      {
        int ret;

        D.28872 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.28872);
        if (ret != 0) goto <D.28956>; else goto <D.28957>;
        <D.28956>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28957>:
        D.28958 = ret != 0;
        D.28959 = (long int) D.28958;
        D.28960 = __builtin_expect (D.28959, 0);
        if (D.28960 != 0) goto <D.28961>; else goto <D.28962>;
        <D.28961>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.28962>:
      }
      D.28963 = addr == 0B;
      D.28964 = (long int) D.28963;
      D.28965 = __builtin_expect (D.28964, 0);
      if (D.28965 != 0) goto <D.28966>; else goto <D.28967>;
      <D.28966>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.28967>:
      D.28968 = addr;
      return D.28968;
    }
    <D.28945>:
    D.28969 = vtable == 0B;
    D.28970 = (long int) D.28969;
    D.28971 = __builtin_expect (D.28970, 0);
    if (D.28971 != 0) goto <D.28972>; else goto <D.28973>;
    <D.28972>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.28973>:
    D.28976 = BIT_FIELD_REF <*vtable, 64, 320>;
    D.28977 = D.28976 & 33554432;
    if (D.28977 == 0) goto <D.28978>; else goto <D.28974>;
    <D.28978>:
    D.28979 = vtable->klass;
    D.28980 = D.28979->flags;
    D.28981 = D.28980 & 1048576;
    if (D.28981 == 0) goto <D.28982>; else goto <D.28974>;
    <D.28982>:
    if (method != 0B) goto <D.28983>; else goto <D.28974>;
    <D.28983>:
    D.28979 = vtable->klass;
    D.28984 = mono_class_needs_cctor_run (D.28979, method);
    if (D.28984 != 0) goto <D.28985>; else goto <D.28974>;
    <D.28985>:
    goto <D.28975>;
    <D.28974>:
    if (run_cctors != 0) goto <D.28986>; else goto <D.28987>;
    <D.28986>:
    mono_runtime_class_init (vtable);
    <D.28987>:
    <D.28975>:
    D.28988 = mono_vtable_get_static_field_data (vtable);
    D.28941 = patch_info->data.field;
    D.28989 = D.28941->offset;
    D.28990 = (sizetype) D.28989;
    target = D.28988 + D.28990;
    goto <D.26002>;
  }
  <D.26039>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.28991 = patch_info->data.token;
        D.28992 = D.28991->token;
        field_index = D.28992 & 16777215;
        D.28991 = patch_info->data.token;
        D.28993 = D.28991->image;
        D.28994 = field_index + 4294967295;
        mono_metadata_field_info (D.28993, D.28994, 0B, &rva, 0B);
        D.28991 = patch_info->data.token;
        D.28993 = D.28991->image;
        rva.65 = rva;
        target = mono_image_rva_map (D.28993, rva.65);
        goto <D.26002>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.26042>:
  <D.26043>:
  target = patch_info->data.target;
  goto <D.26002>;
  <D.26044>:
  target = patch_info->data.name;
  goto <D.26002>;
  <D.26045>:
  D.28991 = patch_info->data.token;
  D.28993 = D.28991->image;
  D.28991 = patch_info->data.token;
  D.28992 = D.28991->token;
  D.28996 = D.28992 & 16777215;
  target = mono_ldstr (domain, D.28993, D.28996);
  goto <D.26002>;
  <D.26046>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28991 = patch_info->data.token;
        D.28993 = D.28991->image;
        D.28991 = patch_info->data.token;
        D.28992 = D.28991->token;
        D.28991 = patch_info->data.token;
        D.28998 = D.28991->has_context;
        if (D.28998 != 0) goto <D.28999>; else goto <D.29000>;
        <D.28999>:
        D.28991 = patch_info->data.token;
        iftmp.66 = &D.28991->context;
        goto <D.29001>;
        <D.29000>:
        iftmp.66 = 0B;
        <D.29001>:
        handle = mono_ldtoken (D.28993, D.28992, &handle_class, iftmp.66);
        handle_class.67 = handle_class;
        mono_class_init (handle_class.67);
        D.29003 = mono_class_from_mono_type (handle);
        mono_class_init (D.29003);
        target = mono_type_get_object (domain, handle);
        goto <D.26002>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.26049>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.28991 = patch_info->data.token;
        D.28993 = D.28991->image;
        D.28991 = patch_info->data.token;
        D.28992 = D.28991->token;
        D.28991 = patch_info->data.token;
        D.28998 = D.28991->has_context;
        if (D.28998 != 0) goto <D.29005>; else goto <D.29006>;
        <D.29005>:
        D.28991 = patch_info->data.token;
        iftmp.68 = &D.28991->context;
        goto <D.29007>;
        <D.29006>:
        iftmp.68 = 0B;
        <D.29007>:
        handle = mono_ldtoken (D.28993, D.28992, &handle_class, iftmp.68);
        handle_class.69 = handle_class;
        mono_class_init (handle_class.69);
        target = handle;
        goto <D.26002>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.26052>:
  D.28991 = patch_info->data.token;
  D.28993 = D.28991->image;
  D.28991 = patch_info->data.token;
  D.28992 = D.28991->token;
  D.29009 = mono_metadata_blob_heap (D.28993, D.28992);
  target = D.29009 + 2;
  goto <D.26002>;
  <D.26053>:
  D.28868 = patch_info->data.method;
  D.29010 = D.28868->flags;
  D.29011 = (int) D.29010;
  D.29012 = D.29011 & 8192;
  if (D.29012 != 0) goto <D.29013>; else goto <D.29014>;
  <D.29013>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.29015>; else goto <D.29016>;
        <D.29015>:
        D.28868 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.28868, &exc_class, &exc_arg);
        if (target == 0B) goto <D.29017>; else goto <D.29018>;
        <D.29017>:
        mono_aot_only.64 = mono_aot_only;
        if (mono_aot_only.64 != 0) goto <D.29019>; else goto <D.29020>;
        <D.29019>:
        D.29021 = mono_defaults.corlib;
        exc_class.70 = exc_class;
        exc_arg.71 = exc_arg;
        D.29024 = mono_exception_from_name_msg (D.29021, "System", exc_class.70, exc_arg.71);
        mono_raise_exception (D.29024);
        <D.29020>:
        D.28868 = patch_info->data.method;
        D.29025 = mono_method_full_name (D.28868, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.29025);
        <D.26056>:
        goto <D.26056>;
        <D.29018>:
        goto <D.29026>;
        <D.29016>:
        target = 0B;
        <D.29026>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.29027>;
  <D.29014>:
  D.28868 = patch_info->data.method;
  target = mono_lookup_internal_call (D.28868);
  if (target == 0B) goto <D.29028>; else goto <D.29029>;
  <D.29028>:
  if (run_cctors != 0) goto <D.29030>; else goto <D.29031>;
  <D.29030>:
  D.28868 = patch_info->data.method;
  D.29032 = mono_method_full_name (D.28868, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.29032);
  <D.26057>:
  goto <D.26057>;
  <D.29031>:
  <D.29029>:
  <D.29027>:
  goto <D.26002>;
  <D.26058>:
  target = mono_thread_interruption_request_flag ();
  goto <D.26002>;
  <D.26059>:
  {
    struct MonoVTable * vtable;

    D.28868 = patch_info->data.method;
    D.29033 = D.28868->klass;
    vtable = mono_class_vtable (domain, D.29033);
    D.29034 = vtable == 0B;
    D.29035 = (long int) D.29034;
    D.29036 = __builtin_expect (D.29035, 0);
    if (D.29036 != 0) goto <D.29037>; else goto <D.29038>;
    <D.29037>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.29038>:
    D.28868 = patch_info->data.method;
    D.29039 = mini_method_get_context (D.28868);
    D.29040 = D.29039->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.29040);
    goto <D.26002>;
  }
  <D.26061>:
  <D.26062>:
  <D.26063>:
  <D.26064>:
  goto <D.26002>;
  <D.26065>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.29041 = entry->data;
    D.29042 = D.29041->type;
    switch (D.29042) <default: <D.26085>, case 3: <D.26070>, case 6: <D.26071>, case 11: <D.26068>, case 13: <D.26072>, case 44: <D.26073>, case 45: <D.26074>, case 46: <D.26076>>
    <D.26068>:
    D.29043 = entry->method;
    D.29044 = entry->in_mrgctx;
    D.29041 = entry->data;
    D.29045 = D.29041->data.klass;
    D.29046 = &D.29045->byval_arg;
    D.29047 = entry->info_type;
    D.29043 = entry->method;
    D.29048 = mono_method_get_context (D.29043);
    slot = mono_method_lookup_or_register_info (D.29043, D.29044, D.29046, D.29047, D.29048);
    goto <D.26069>;
    <D.26070>:
    <D.26071>:
    D.29043 = entry->method;
    D.29044 = entry->in_mrgctx;
    D.29041 = entry->data;
    D.29049 = D.29041->data.method;
    D.29047 = entry->info_type;
    D.29043 = entry->method;
    D.29050 = mono_method_get_context (D.29043);
    slot = mono_method_lookup_or_register_info (D.29043, D.29044, D.29049, D.29047, D.29050);
    goto <D.26069>;
    <D.26072>:
    D.29043 = entry->method;
    D.29044 = entry->in_mrgctx;
    D.29041 = entry->data;
    D.29051 = D.29041->data.field;
    D.29047 = entry->info_type;
    D.29043 = entry->method;
    D.29052 = mono_method_get_context (D.29043);
    slot = mono_method_lookup_or_register_info (D.29043, D.29044, D.29051, D.29047, D.29052);
    goto <D.26069>;
    <D.26073>:
    D.29043 = entry->method;
    D.29044 = entry->in_mrgctx;
    D.29041 = entry->data;
    D.29053 = D.29041->data.sig;
    D.29047 = entry->info_type;
    D.29043 = entry->method;
    D.29054 = mono_method_get_context (D.29043);
    slot = mono_method_lookup_or_register_info (D.29043, D.29044, D.29053, D.29047, D.29054);
    goto <D.26069>;
    <D.26074>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (16);
      D.29041 = entry->data;
      D.29055 = D.29041->data.gsharedvt;
      memcpy (call_info, D.29055, 16);
      D.29043 = entry->method;
      D.29044 = entry->in_mrgctx;
      D.29047 = entry->info_type;
      D.29043 = entry->method;
      D.29056 = mono_method_get_context (D.29043);
      slot = mono_method_lookup_or_register_info (D.29043, D.29044, call_info, D.29047, D.29056);
      goto <D.26069>;
    }
    <D.26076>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.29041 = entry->data;
      oinfo = D.29041->data.gsharedvt_method;
      info = monoeg_malloc0 (16);
      D.29057 = oinfo->method;
      info->method = D.29057;
      D.29058 = monoeg_g_ptr_array_new ();
      info->entries = D.29058;
      i = 0;
      goto <D.26083>;
      <D.26082>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.29059 = oinfo->entries;
        D.29060 = D.29059->pdata;
        D.29061 = (long unsigned int) i;
        D.29062 = D.29061 * 8;
        D.29063 = D.29060 + D.29062;
        otemplate = *D.29063;
        template = monoeg_malloc0 (24);
        memcpy (template, otemplate, 24);
        D.29064 = info->entries;
        monoeg_g_ptr_array_add (D.29064, template);
      }
      i = i + 1;
      <D.26083>:
      i.72 = (unsigned int) i;
      D.29059 = oinfo->entries;
      D.29066 = D.29059->len;
      if (i.72 < D.29066) goto <D.26082>; else goto <D.26084>;
      <D.26084>:
      D.29043 = entry->method;
      D.29044 = entry->in_mrgctx;
      D.29047 = entry->info_type;
      D.29043 = entry->method;
      D.29067 = mono_method_get_context (D.29043);
      slot = mono_method_lookup_or_register_info (D.29043, D.29044, info, D.29047, D.29067);
      goto <D.26069>;
    }
    <D.26085>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.26069>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.26002>;
  }
  <D.26086>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.26002>;
  <D.26087>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.26002>;
  <D.26088>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.26002>;
  <D.26089>:
  if (run_cctors == 0) goto <D.29068>; else goto <D.29069>;
  <D.29068>:
  target = 0B;
  goto <D.29070>;
  <D.29069>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.29070>:
  goto <D.26002>;
  <D.26090>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3609);
  <D.26091>:
  {
    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.26002>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.26094>:
  target = mono_domain_alloc0 (domain, 8);
  goto <D.26002>;
  <D.26095>:
  mono_jit_tls_id.73 = mono_jit_tls_id;
  D.29072 = (long unsigned int) mono_jit_tls_id.73;
  target = (const void *) D.29072;
  goto <D.26002>;
  <D.26096>:
  {
    int offset;

    D.29073 = patch_info->data.target;
    D.29074 = (long int) D.29073;
    D.29075 = (<unnamed type>) D.29074;
    offset = mini_get_tls_offset (D.29075);
    D.29076 = (long int) offset;
    target = (const void *) D.29076;
    goto <D.26002>;
  }
  <D.26098>:
  target = 0B;
  goto <D.26002>;
  <D.26099>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.26002>:
  D.28968 = target;
  return D.28968;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.29083;
  struct GHashTable * D.29084;
  struct MonoJitDynamicMethodInfo * D.29088;
  struct MonoJitDynamicMethodInfo * res;

  D.29083 = domain->runtime_info;
  D.29084 = MEM[(struct MonoJitDomainInfo *)D.29083].dynamic_code_hash;
  if (D.29084 != 0B) goto <D.29085>; else goto <D.29086>;
  <D.29085>:
  D.29083 = domain->runtime_info;
  D.29084 = MEM[(struct MonoJitDomainInfo *)D.29083].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.29084, method);
  goto <D.29087>;
  <D.29086>:
  res = 0B;
  <D.29087>:
  D.29088 = res;
  return D.29088;
}


mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  long int D.29090;
  struct GPtrArray * D.29091;
  struct MonoMemPool * D.29094;
  struct GSList * D.29095;
  struct GSList * D.29096;

  D.29090 = (long int) native_offset;
  ins->data.op[0].const_val = D.29090;
  D.29091 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.29091, ins);
  if (bb != 0B) goto <D.29092>; else goto <D.29093>;
  <D.29092>:
  D.29094 = cfg->mempool;
  D.29095 = bb->seq_points;
  D.29096 = g_slist_prepend_mempool (D.29094, D.29095, ins);
  bb->seq_points = D.29096;
  bb->last_seq_point = ins;
  <D.29093>:
}


mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.29097;
  _Bool D.29100;
  long int D.29101;
  long int D.29102;
  struct MonoInst * * D.29105;
  struct MonoInst * D.29106;
  struct GSList * D.29109;
  struct GSList * D.29110;
  struct MonoInst * D.29112;
  struct GSList * D.29115;
  struct GSList * D.29116;
  struct MonoDwarfLocListEntry * entry;

  D.29097 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.29097, 20);
  if (is_reg != 0) goto <D.29098>; else goto <D.29099>;
  <D.29098>:
  D.29100 = offset != 0;
  D.29101 = (long int) D.29100;
  D.29102 = __builtin_expect (D.29101, 0);
  if (D.29102 != 0) goto <D.29103>; else goto <D.29104>;
  <D.29103>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.29104>:
  <D.29099>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.29105 = cfg->args;
  D.29106 = *D.29105;
  if (D.29106 == var) goto <D.29107>; else goto <D.29108>;
  <D.29107>:
  D.29097 = cfg->mempool;
  D.29109 = cfg->this_loclist;
  D.29110 = g_slist_append_mempool (D.29097, D.29109, entry);
  cfg->this_loclist = D.29110;
  goto <D.29111>;
  <D.29108>:
  D.29112 = cfg->rgctx_var;
  if (D.29112 == var) goto <D.29113>; else goto <D.29114>;
  <D.29113>:
  D.29097 = cfg->mempool;
  D.29115 = cfg->rgctx_loclist;
  D.29116 = g_slist_append_mempool (D.29097, D.29115, entry);
  cfg->rgctx_loclist = D.29116;
  <D.29114>:
  <D.29111>:
}


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

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


mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.74;
  unsigned int D.29121;
  unsigned int D.29122;
  long unsigned int D.29125;
  long unsigned int D.29126;
  unsigned int D.29131;
  unsigned int D.29132;
  struct MonoMethod * D.29135;
  unsigned int D.29136;
  int D.29137;
  struct MonoProfileCoverageInfo * D.29138;
  unsigned int D.29139;
  long int code.75;
  unsigned char * D.29143;
  long int D.29144;
  long int D.29145;
  unsigned int D.29146;
  unsigned int D.29147;
  int D.29148;
  int D.29149;
  unsigned int D.29150;
  unsigned int D.29151;
  int D.29152;
  struct MonoBasicBlock * D.29153;
  sizetype D.29158;
  unsigned int D.29159;
  _Bool D.29160;
  long int D.29161;
  long int D.29162;
  unsigned int max_epilog_size.76;
  unsigned int D.29166;
  long unsigned int D.29167;
  long unsigned int D.29168;
  void * D.29171;
  struct MonoJitDynamicMethodInfo * D.29172;
  struct MonoCodeManager * D.29173;
  struct MonoDomain * D.29174;
  union mono_mutex_t * D.29175;
  _Bool D.29178;
  long int D.29179;
  long int D.29180;
  _Bool D.29185;
  long int D.29186;
  long int D.29187;
  unsigned int D.29192;
  int D.29193;
  struct MonoCodeManager * D.29195;
  unsigned int D.29197;
  int D.29198;
  _Bool D.29199;
  long int D.29200;
  long int D.29201;
  long unsigned int D.29204;
  unsigned int D.29205;
  unsigned char * D.29208;
  char * D.29209;
  long unsigned int D.29212;
  struct MonoGenericContainer * D.29214;
  struct MonoClass * D.29216;
  struct MonoGenericContainer * D.29217;
  struct MonoGenericClass * D.29219;
  struct MonoGenericSharingContext * D.29220;
  _Bool D.29223;
  long int D.29224;
  long int D.29225;
  struct MonoJumpInfo * D.29228;
  struct MonoCodeManager * iftmp.77;
  <unnamed-unsigned:1> D.29233;
  int D.29234;
  int D.29239;
  int D.29242;
  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.29118>; else goto <D.29119>;
  <D.29118>:
  code_domain = mono_get_root_domain ();
  goto <D.29120>;
  <D.29119>:
  code_domain = cfg->domain;
  <D.29120>:
  bb = cfg->bb_entry;
  goto <D.26235>;
  <D.26234>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.29121 = cfg->opt;
  D.29122 = D.29121 & 1;
  if (D.29122 != 0) goto <D.29123>; else goto <D.29124>;
  <D.29123>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.29124>:
  D.29125 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29126 = D.29125 & 17592186044416;
  if (D.29126 == 0) goto <D.29127>; else goto <D.29128>;
  <D.29127>:
  mono_local_regalloc (cfg, bb);
  <D.29128>:
  D.29121 = cfg->opt;
  D.29122 = D.29121 & 1;
  if (D.29122 != 0) goto <D.29129>; else goto <D.29130>;
  <D.29129>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.29130>:
  bb = bb->next_bb;
  <D.26235>:
  if (bb != 0B) goto <D.26234>; else goto <D.26236>;
  <D.26236>:
  D.29131 = cfg->prof_options;
  D.29132 = D.29131 & 8192;
  if (D.29132 != 0) goto <D.29133>; else goto <D.29134>;
  <D.29133>:
  D.29135 = cfg->method;
  D.29136 = cfg->num_bblocks;
  D.29137 = (int) D.29136;
  D.29138 = mono_profiler_coverage_alloc (D.29135, D.29137);
  cfg->coverage_info = D.29138;
  <D.29134>:
  code = mono_arch_emit_prolog (cfg);
  D.29131 = cfg->prof_options;
  D.29139 = D.29131 & 4096;
  if (D.29139 != 0) goto <D.29140>; else goto <D.29141>;
  <D.29140>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.29141>:
  code.75 = (long int) code;
  D.29143 = cfg->native_code;
  D.29144 = (long int) D.29143;
  D.29145 = code.75 - D.29144;
  D.29146 = (unsigned int) D.29145;
  cfg->code_len = D.29146;
  D.29147 = cfg->code_len;
  cfg->prolog_end = D.29147;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.26238>;
  <D.26237>:
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  bb->native_offset = D.29148;
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  bb->real_native_offset = D.29148;
  mono_arch_output_basic_block (cfg, bb);
  D.29147 = cfg->code_len;
  D.29149 = bb->native_offset;
  D.29150 = (unsigned int) D.29149;
  D.29151 = D.29147 - D.29150;
  D.29152 = (int) D.29151;
  bb->native_length = D.29152;
  D.29153 = cfg->bb_exit;
  if (D.29153 == bb) goto <D.29154>; else goto <D.29155>;
  <D.29154>:
  D.29147 = cfg->code_len;
  cfg->epilog_begin = D.29147;
  D.29131 = cfg->prof_options;
  D.29139 = D.29131 & 4096;
  if (D.29139 != 0) goto <D.29156>; else goto <D.29157>;
  <D.29156>:
  D.29143 = cfg->native_code;
  D.29147 = cfg->code_len;
  D.29158 = (sizetype) D.29147;
  code = D.29143 + D.29158;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.75 = (long int) code;
  D.29143 = cfg->native_code;
  D.29144 = (long int) D.29143;
  D.29145 = code.75 - D.29144;
  D.29146 = (unsigned int) D.29145;
  cfg->code_len = D.29146;
  D.29147 = cfg->code_len;
  D.29159 = cfg->code_size;
  D.29160 = D.29147 >= D.29159;
  D.29161 = (long int) D.29160;
  D.29162 = __builtin_expect (D.29161, 0);
  if (D.29162 != 0) goto <D.29163>; else goto <D.29164>;
  <D.29163>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.29164>:
  <D.29157>:
  mono_arch_emit_epilog (cfg);
  <D.29155>:
  bb = bb->next_bb;
  <D.26238>:
  if (bb != 0B) goto <D.26237>; else goto <D.26239>;
  <D.26239>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.29147 = cfg->code_len;
  max_epilog_size.76 = (unsigned int) max_epilog_size;
  D.29166 = D.29147 + max_epilog_size.76;
  cfg->code_size = D.29166;
  D.29135 = cfg->method;
  D.29167 = BIT_FIELD_REF <*D.29135, 64, 256>;
  D.29168 = D.29167 & 512;
  if (D.29168 != 0) goto <D.29169>; else goto <D.29170>;
  <D.29169>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29171 = monoeg_malloc0 (16);
    cfg->dynamic_info = D.29171;
    D.29172 = cfg->dynamic_info;
    D.29173 = mono_code_manager_new_dynamic ();
    D.29172->code_mp = D.29173;
    {
      int ret;

      D.29174 = cfg->domain;
      D.29175 = &D.29174->lock.mutex;
      ret = pthread_mutex_lock (D.29175);
      if (ret != 0) goto <D.29176>; else goto <D.29177>;
      <D.29176>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29177>:
      D.29178 = ret != 0;
      D.29179 = (long int) D.29178;
      D.29180 = __builtin_expect (D.29179, 0);
      if (D.29180 != 0) goto <D.29181>; else goto <D.29182>;
      <D.29181>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.29182>:
    }
    D.29174 = cfg->domain;
    D.29135 = cfg->method;
    D.29172 = cfg->dynamic_info;
    mono_dynamic_code_hash_insert (D.29174, D.29135, D.29172);
    {
      int ret;

      D.29174 = cfg->domain;
      D.29175 = &D.29174->lock.mutex;
      ret = pthread_mutex_unlock (D.29175);
      if (ret != 0) goto <D.29183>; else goto <D.29184>;
      <D.29183>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29184>:
      D.29185 = ret != 0;
      D.29186 = (long int) D.29185;
      D.29187 = __builtin_expect (D.29186, 0);
      if (D.29187 != 0) goto <D.29188>; else goto <D.29189>;
      <D.29188>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.29189>:
    }
    mono_using_xdebug.74 = mono_using_xdebug;
    if (mono_using_xdebug.74 != 0) goto <D.29190>; else goto <D.29191>;
    <D.29190>:
    D.29159 = cfg->code_size;
    D.29192 = D.29159 + unwindlen;
    D.29193 = (int) D.29192;
    code = mono_domain_code_reserve (code_domain, D.29193);
    goto <D.29194>;
    <D.29191>:
    D.29172 = cfg->dynamic_info;
    D.29195 = D.29172->code_mp;
    D.29159 = cfg->code_size;
    D.29192 = D.29159 + unwindlen;
    D.29193 = (int) D.29192;
    code = mono_code_manager_reserve (D.29195, D.29193);
    <D.29194>:
  }
  goto <D.29196>;
  <D.29170>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.29159 = cfg->code_size;
    D.29197 = D.29159 + unwindlen;
    D.29198 = (int) D.29197;
    code = mono_domain_code_reserve (code_domain, D.29198);
  }
  <D.29196>:
  D.29199 = code == 0B;
  D.29200 = (long int) D.29199;
  D.29201 = __builtin_expect (D.29200, 0);
  if (D.29201 != 0) goto <D.29202>; else goto <D.29203>;
  <D.29202>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.29203>:
  D.29143 = cfg->native_code;
  D.29147 = cfg->code_len;
  D.29204 = (long unsigned int) D.29147;
  memcpy (code, D.29143, D.29204);
  D.29143 = cfg->native_code;
  monoeg_g_free (D.29143);
  cfg->native_code = code;
  D.29143 = cfg->native_code;
  D.29147 = cfg->code_len;
  D.29158 = (sizetype) D.29147;
  code = D.29143 + D.29158;
  mono_postprocess_patches (cfg);
  D.29205 = cfg->verbose_level;
  if (D.29205 != 0) goto <D.29206>; else goto <D.29207>;
  <D.29206>:
  {
    char * nm;

    D.29135 = cfg->method;
    nm = mono_method_full_name (D.29135, 1);
    D.29143 = cfg->native_code;
    D.29143 = cfg->native_code;
    D.29147 = cfg->code_len;
    D.29158 = (sizetype) D.29147;
    D.29208 = D.29143 + D.29158;
    D.29147 = cfg->code_len;
    D.29174 = cfg->domain;
    D.29209 = D.29174->friendly_name;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.29143, D.29208, D.29147, D.29209);
    monoeg_g_free (nm);
  }
  <D.29207>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.29135 = cfg->method;
    D.29167 = BIT_FIELD_REF <*D.29135, 64, 256>;
    D.29212 = D.29167 & 4096;
    if (D.29212 != 0) goto <D.29210>; else goto <D.29213>;
    <D.29213>:
    D.29135 = cfg->method;
    D.29214 = mono_method_get_generic_container (D.29135);
    if (D.29214 != 0B) goto <D.29210>; else goto <D.29215>;
    <D.29215>:
    D.29135 = cfg->method;
    D.29216 = D.29135->klass;
    D.29217 = D.29216->generic_container;
    if (D.29217 != 0B) goto <D.29210>; else goto <D.29218>;
    <D.29218>:
    D.29135 = cfg->method;
    D.29216 = D.29135->klass;
    D.29219 = D.29216->generic_class;
    if (D.29219 != 0B) goto <D.29210>; else goto <D.29211>;
    <D.29210>:
    is_generic = 1;
    <D.29211>:
    D.29220 = cfg->generic_sharing_context;
    if (D.29220 != 0B) goto <D.29221>; else goto <D.29222>;
    <D.29221>:
    D.29223 = is_generic == 0;
    D.29224 = (long int) D.29223;
    D.29225 = __builtin_expect (D.29224, 0);
    if (D.29225 != 0) goto <D.29226>; else goto <D.29227>;
    <D.29226>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.29227>:
    <D.29222>:
  }
  D.29135 = cfg->method;
  D.29174 = cfg->domain;
  D.29143 = cfg->native_code;
  D.29228 = cfg->patch_info;
  D.29172 = cfg->dynamic_info;
  if (D.29172 != 0B) goto <D.29230>; else goto <D.29231>;
  <D.29230>:
  D.29172 = cfg->dynamic_info;
  iftmp.77 = D.29172->code_mp;
  goto <D.29232>;
  <D.29231>:
  iftmp.77 = 0B;
  <D.29232>:
  D.29233 = cfg->run_cctors;
  D.29234 = (int) D.29233;
  mono_arch_patch_code (D.29135, D.29174, D.29143, D.29228, iftmp.77, D.29234);
  D.29135 = cfg->method;
  D.29167 = BIT_FIELD_REF <*D.29135, 64, 256>;
  D.29168 = D.29167 & 512;
  if (D.29168 != 0) goto <D.29235>; else goto <D.29236>;
  <D.29235>:
  mono_using_xdebug.74 = mono_using_xdebug;
  if (mono_using_xdebug.74 != 0) goto <D.29237>; else goto <D.29238>;
  <D.29237>:
  D.29143 = cfg->native_code;
  D.29159 = cfg->code_size;
  D.29239 = (int) D.29159;
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  mono_domain_code_commit (code_domain, D.29143, D.29239, D.29148);
  goto <D.29240>;
  <D.29238>:
  D.29172 = cfg->dynamic_info;
  D.29195 = D.29172->code_mp;
  D.29143 = cfg->native_code;
  D.29159 = cfg->code_size;
  D.29239 = (int) D.29159;
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  mono_code_manager_commit (D.29195, D.29143, D.29239, D.29148);
  <D.29240>:
  goto <D.29241>;
  <D.29236>:
  D.29143 = cfg->native_code;
  D.29159 = cfg->code_size;
  D.29239 = (int) D.29159;
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  mono_domain_code_commit (code_domain, D.29143, D.29239, D.29148);
  <D.29241>:
  D.29143 = cfg->native_code;
  D.29147 = cfg->code_len;
  D.29148 = (int) D.29147;
  D.29135 = cfg->method;
  mono_profiler_code_buffer_new (D.29143, D.29148, 1, D.29135);
  D.29143 = cfg->native_code;
  D.29147 = cfg->code_len;
  D.29242 = (int) D.29147;
  mono_arch_flush_icache (D.29143, D.29242);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.29243;
  struct GHashTable * D.29244;
  struct GHashTable * D.29247;

  D.29243 = domain->runtime_info;
  D.29244 = MEM[(struct MonoJitDomainInfo *)D.29243].dynamic_code_hash;
  if (D.29244 == 0B) goto <D.29245>; else goto <D.29246>;
  <D.29245>:
  D.29243 = domain->runtime_info;
  D.29247 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.29243].dynamic_code_hash = D.29247;
  <D.29246>:
  D.29243 = domain->runtime_info;
  D.29244 = MEM[(struct MonoJitDomainInfo *)D.29243].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.29244, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.29248;
  const void * D.29249;
  const char * D.29252;
  char * D.29253;
  char * D.29256;
  struct GHashTable * D.29261;
  <unnamed type> D.29266;
  const void * D.29267;
  struct MonoMethod * D.29268;
  long unsigned int D.29269;
  long unsigned int D.29270;
  struct MonoJitDynamicMethodInfo * D.29273;
  struct MonoCodeManager * D.29274;
  struct MonoJumpInfoBBTable * D.29275;
  int D.29276;
  unsigned int D.29277;
  unsigned int D.29278;
  int D.29279;
  struct MonoDomain * D.29281;
  struct MonoBasicBlock * * D.29282;
  long unsigned int D.29283;
  long unsigned int D.29284;
  struct MonoBasicBlock * * D.29285;
  struct MonoBasicBlock * D.29286;
  int D.29289;
  _Bool D.29290;
  long int D.29291;
  long int D.29292;
  void * * D.29295;
  long int D.29296;
  void * D.29297;
  unsigned char * D.29299;
  int D.29300;
  sizetype D.29301;
  union mono_mutex_t * D.29302;
  _Bool D.29305;
  long int D.29306;
  long int D.29307;
  void * D.29310;
  struct GHashTable * D.29311;
  struct MonoMethod * D.29312;
  struct GSList * D.29315;
  struct GSList * D.29316;
  _Bool D.29319;
  long int D.29320;
  long int D.29321;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.26162>;
  <D.26161>:
  D.29248 = patch_info->type;
  switch (D.29248) <default: <D.26160>, case 1: <D.26145>, case 4: <D.26154>, case 8: <D.26149>>
  <D.26145>:
  {
    struct MonoJitICallInfo * info;

    D.29249 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.29249);
    if (info != 0B) goto <D.29250>; else goto <D.29251>;
    <D.29250>:
    D.29252 = info->name;
    D.29253 = strstr (D.29252, "ves_array_new_va_");
    if (D.29253 == 0B) goto <D.29254>; else goto <D.29255>;
    <D.29254>:
    D.29252 = info->name;
    D.29256 = strstr (D.29252, "ves_array_element_address_");
    if (D.29256 == 0B) goto <D.29257>; else goto <D.29258>;
    <D.29257>:
    patch_info->type = 7;
    D.29252 = info->name;
    patch_info->data.name = D.29252;
    <D.29258>:
    <D.29255>:
    <D.29251>:
    D.29248 = patch_info->type;
    if (D.29248 == 1) goto <D.29259>; else goto <D.29260>;
    <D.29259>:
    D.29261 = cfg->abs_patches;
    if (D.29261 != 0B) goto <D.29262>; else goto <D.29263>;
    <D.29262>:
    {
      struct MonoJumpInfo * abs_ji;

      D.29261 = cfg->abs_patches;
      D.29249 = patch_info->data.target;
      abs_ji = monoeg_g_hash_table_lookup (D.29261, D.29249);
      if (abs_ji != 0B) goto <D.29264>; else goto <D.29265>;
      <D.29264>:
      D.29266 = abs_ji->type;
      patch_info->type = D.29266;
      D.29267 = abs_ji->data.target;
      patch_info->data.target = D.29267;
      <D.29265>:
    }
    <D.29263>:
    <D.29260>:
    goto <D.26148>;
  }
  <D.26149>:
  {
    void * * table;

    D.29268 = cfg->method;
    D.29269 = BIT_FIELD_REF <*D.29268, 64, 256>;
    D.29270 = D.29269 & 512;
    if (D.29270 != 0) goto <D.29271>; else goto <D.29272>;
    <D.29271>:
    D.29273 = cfg->dynamic_info;
    D.29274 = D.29273->code_mp;
    D.29275 = patch_info->data.table;
    D.29276 = D.29275->table_size;
    D.29277 = (unsigned int) D.29276;
    D.29278 = D.29277 * 8;
    D.29279 = (int) D.29278;
    table = mono_code_manager_reserve (D.29274, D.29279);
    goto <D.29280>;
    <D.29272>:
    D.29281 = cfg->domain;
    D.29275 = patch_info->data.table;
    D.29276 = D.29275->table_size;
    D.29277 = (unsigned int) D.29276;
    D.29278 = D.29277 * 8;
    D.29279 = (int) D.29278;
    table = mono_domain_code_reserve (D.29281, D.29279);
    <D.29280>:
    i = 0;
    goto <D.26152>;
    <D.26151>:
    D.29275 = patch_info->data.table;
    D.29282 = D.29275->table;
    D.29283 = (long unsigned int) i;
    D.29284 = D.29283 * 8;
    D.29285 = D.29282 + D.29284;
    D.29286 = *D.29285;
    if (D.29286 != 0B) goto <D.29287>; else goto <D.29288>;
    <D.29287>:
    D.29275 = patch_info->data.table;
    D.29282 = D.29275->table;
    D.29283 = (long unsigned int) i;
    D.29284 = D.29283 * 8;
    D.29285 = D.29282 + D.29284;
    D.29286 = *D.29285;
    D.29289 = D.29286->native_offset;
    D.29290 = D.29289 == 0;
    D.29291 = (long int) D.29290;
    D.29292 = __builtin_expect (D.29291, 0);
    if (D.29292 != 0) goto <D.29293>; else goto <D.29294>;
    <D.29293>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.29294>:
    D.29283 = (long unsigned int) i;
    D.29284 = D.29283 * 8;
    D.29295 = table + D.29284;
    D.29275 = patch_info->data.table;
    D.29282 = D.29275->table;
    D.29283 = (long unsigned int) i;
    D.29284 = D.29283 * 8;
    D.29285 = D.29282 + D.29284;
    D.29286 = *D.29285;
    D.29289 = D.29286->native_offset;
    D.29296 = (long int) D.29289;
    D.29297 = (void *) D.29296;
    *D.29295 = D.29297;
    goto <D.29298>;
    <D.29288>:
    D.29283 = (long unsigned int) i;
    D.29284 = D.29283 * 8;
    D.29295 = table + D.29284;
    *D.29295 = 0B;
    <D.29298>:
    i = i + 1;
    <D.26152>:
    D.29275 = patch_info->data.table;
    D.29276 = D.29275->table_size;
    if (D.29276 > i) goto <D.26151>; else goto <D.26153>;
    <D.26153>:
    D.29275 = patch_info->data.table;
    D.29275->table = table;
    goto <D.26148>;
  }
  <D.26154>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.29299 = cfg->native_code;
    D.29300 = patch_info->ip.i;
    D.29301 = (sizetype) D.29300;
    ip = D.29299 + D.29301;
    {
      int ret;

      D.29302 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.29302);
      if (ret != 0) goto <D.29303>; else goto <D.29304>;
      <D.29303>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29304>:
      D.29305 = ret != 0;
      D.29306 = (long int) D.29305;
      D.29307 = __builtin_expect (D.29306, 0);
      if (D.29307 != 0) goto <D.29308>; else goto <D.29309>;
      <D.29308>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.29309>:
    }
    D.29310 = domain->runtime_info;
    D.29311 = MEM[(struct MonoJitDomainInfo *)D.29310].jump_target_hash;
    D.29312 = patch_info->data.method;
    jlist = monoeg_g_hash_table_lookup (D.29311, D.29312);
    if (jlist == 0B) goto <D.29313>; else goto <D.29314>;
    <D.29313>:
    jlist = mono_domain_alloc0 (domain, 8);
    D.29310 = domain->runtime_info;
    D.29311 = MEM[(struct MonoJitDomainInfo *)D.29310].jump_target_hash;
    D.29312 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.29311, D.29312, jlist, 0);
    <D.29314>:
    D.29315 = jlist->list;
    D.29316 = monoeg_g_slist_prepend (D.29315, ip);
    jlist->list = D.29316;
    {
      int ret;

      D.29302 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.29302);
      if (ret != 0) goto <D.29317>; else goto <D.29318>;
      <D.29317>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29318>:
      D.29319 = ret != 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", 3842, "ret == 0");
      <D.29323>:
    }
    goto <D.26148>;
  }
  <D.26160>:
  goto <D.26148>;
  <D.26148>:
  patch_info = patch_info->next;
  <D.26162>:
  if (patch_info != 0B) goto <D.26161>; else goto <D.26163>;
  <D.26163>:
}


mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  long unsigned int D.29328;
  long unsigned int D.29329;
  struct MonoClass * D.29331;
  struct MonoGenericContainer * D.29332;
  long unsigned int D.29334;
  long unsigned int D.29335;
  long unsigned int D.29336;
  struct MonoGenericContainer * D.29339;
  struct MonoClass * D.29341;
  struct MonoGenericContainer * D.29342;
  int D.29348;
  int D.29350;
  int iftmp.78;
  int D.29357;
  struct MonoGenericInst * D.29363;
  struct MonoGenericInst * D.29364;
  struct MonoGenericInst * D.29370;
  struct MonoGenericInst * D.29371;
  struct MonoClass * D.29374;
  long unsigned int D.29375;
  long unsigned int D.29376;
  _Bool D.29377;
  long int D.29378;
  long int D.29379;
  struct MonoMethod * D.29382;
  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.29328 = BIT_FIELD_REF <*method, 64, 256>;
      D.29329 = D.29328 & 2048;
      if (D.29329 != 0) goto <D.29325>; else goto <D.29330>;
      <D.29330>:
      D.29331 = method->klass;
      D.29332 = D.29331->generic_container;
      if (D.29332 != 0B) goto <D.29333>; else goto <D.29326>;
      <D.29333>:
      D.29328 = BIT_FIELD_REF <*method, 64, 256>;
      D.29334 = D.29328 & 4096;
      if (D.29334 == 0) goto <D.29325>; else goto <D.29326>;
      <D.29325>:
      declaring_method = method;
      goto <D.29327>;
      <D.29326>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.29327>:
      D.29335 = BIT_FIELD_REF <*declaring_method, 64, 256>;
      D.29336 = D.29335 & 2048;
      if (D.29336 != 0) goto <D.29337>; else goto <D.29338>;
      <D.29337>:
      D.29339 = mono_method_get_generic_container (declaring_method);
      shared_context = D.29339->context;
      goto <D.29340>;
      <D.29338>:
      D.29341 = declaring_method->klass;
      D.29342 = D.29341->generic_container;
      shared_context = D.29342->context;
      <D.29340>:
      if (method != declaring_method) goto <D.29346>; else goto <D.29343>;
      <D.29346>:
      D.29328 = BIT_FIELD_REF <*method, 64, 256>;
      D.29334 = D.29328 & 4096;
      if (D.29334 != 0) goto <D.29347>; else goto <D.29343>;
      <D.29347>:
      D.29348 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29348 == 0) goto <D.29344>; else goto <D.29343>;
      <D.29343>:
      if (is_gsharedvt != 0) goto <D.29344>; else goto <D.29349>;
      <D.29349>:
      D.29350 = mini_is_gsharedvt_sharable_method (method);
      if (D.29350 != 0) goto <D.29344>; else goto <D.29345>;
      <D.29344>:
      {
        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.29352>; else goto <D.29355>;
        <D.29355>:
        if (partial == 0) goto <D.29356>; else goto <D.29353>;
        <D.29356>:
        D.29357 = mini_is_gsharedvt_sharable_method (method);
        if (D.29357 != 0) goto <D.29352>; else goto <D.29353>;
        <D.29352>:
        iftmp.78 = 1;
        goto <D.29354>;
        <D.29353>:
        iftmp.78 = 0;
        <D.29354>:
        gsharedvt = iftmp.78;
        D.29341 = declaring_method->klass;
        class_container = D.29341->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.29358>; else goto <D.29359>;
        <D.29358>:
        inst = context->class_inst;
        goto <D.29360>;
        <D.29359>:
        inst = shared_context.class_inst;
        <D.29360>:
        if (inst != 0B) goto <D.29361>; else goto <D.29362>;
        <D.29361>:
        D.29363 = shared_context.class_inst;
        D.29364 = get_shared_inst (inst, D.29363, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.29364;
        <D.29362>:
        if (context != 0B) goto <D.29365>; else goto <D.29366>;
        <D.29365>:
        inst = context->method_inst;
        goto <D.29367>;
        <D.29366>:
        inst = shared_context.method_inst;
        <D.29367>:
        if (inst != 0B) goto <D.29368>; else goto <D.29369>;
        <D.29368>:
        D.29370 = shared_context.method_inst;
        D.29371 = get_shared_inst (inst, D.29370, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.29371;
        <D.29369>:
        partial = 1;
      }
      <D.29345>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.29372>; else goto <D.29373>;
      <D.29372>:
      D.29374 = res->klass;
      D.29375 = BIT_FIELD_REF <*D.29374, 64, 256>;
      D.29376 = D.29375 & 34359738368;
      D.29377 = D.29376 != 0;
      D.29378 = (long int) D.29377;
      D.29379 = __builtin_expect (D.29378, 0);
      if (D.29379 != 0) goto <D.29380>; else goto <D.29381>;
      <D.29380>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.29381>:
      <D.29373>:
      D.29382 = res;
      return D.29382;
    }
  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.29385;
  long unsigned int D.29386;
  long unsigned int D.29387;
  struct MonoType * D.29392;
  int D.29393;
  unsigned char D.29395;
  long unsigned int D.29397;
  long unsigned int D.29398;
  struct MonoType * * D.29399;
  struct MonoType * D.29400;
  struct MonoType * D.29403;
  struct MonoType * D.29407;
  int D.29409;
  struct MonoGenericInst * D.29410;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.29385 = inst->type_argc;
  D.29386 = (long unsigned int) D.29385;
  D.29387 = D.29386 * 8;
  type_argv = monoeg_malloc0 (D.29387);
  i = 0;
  goto <D.26387>;
  <D.26386>:
  if (all_vt == 0) goto <D.29391>; else goto <D.29388>;
  <D.29391>:
  D.29392 = inst->type_argv[i];
  D.29393 = mono_type_is_reference (D.29392);
  if (D.29393 != 0) goto <D.29389>; else goto <D.29394>;
  <D.29394>:
  D.29392 = inst->type_argv[i];
  D.29395 = D.29392->type;
  if (D.29395 == 19) goto <D.29389>; else goto <D.29396>;
  <D.29396>:
  D.29392 = inst->type_argv[i];
  D.29395 = D.29392->type;
  if (D.29395 == 30) goto <D.29389>; else goto <D.29388>;
  <D.29389>:
  D.29397 = (long unsigned int) i;
  D.29398 = D.29397 * 8;
  D.29399 = type_argv + D.29398;
  D.29400 = shared_inst->type_argv[i];
  *D.29399 = D.29400;
  goto <D.29390>;
  <D.29388>:
  if (all_vt != 0) goto <D.29401>; else goto <D.29402>;
  <D.29401>:
  D.29397 = (long unsigned int) i;
  D.29398 = D.29397 * 8;
  D.29399 = type_argv + D.29398;
  D.29400 = shared_inst->type_argv[i];
  D.29403 = get_gsharedvt_type (D.29400);
  *D.29399 = D.29403;
  goto <D.29404>;
  <D.29402>:
  if (gsharedvt != 0) goto <D.29405>; else goto <D.29406>;
  <D.29405>:
  D.29397 = (long unsigned int) i;
  D.29398 = D.29397 * 8;
  D.29399 = type_argv + D.29398;
  D.29400 = shared_inst->type_argv[i];
  D.29407 = get_gsharedvt_type (D.29400);
  *D.29399 = D.29407;
  goto <D.29408>;
  <D.29406>:
  D.29397 = (long unsigned int) i;
  D.29398 = D.29397 * 8;
  D.29399 = type_argv + D.29398;
  D.29392 = inst->type_argv[i];
  *D.29399 = D.29392;
  <D.29408>:
  <D.29404>:
  <D.29390>:
  i = i + 1;
  <D.26387>:
  D.29385 = inst->type_argc;
  D.29409 = (int) D.29385;
  if (D.29409 > i) goto <D.26386>; else goto <D.26388>;
  <D.26388>:
  D.29385 = inst->type_argc;
  D.29409 = (int) D.29385;
  res = mono_metadata_get_generic_inst (D.29409, type_argv);
  monoeg_g_free (type_argv);
  D.29410 = res;
  return D.29410;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.79;
  struct MonoGenericContainer * D.29416;
  struct MonoGenericParamInfo * D.29418;
  _Bool D.29419;
  long int D.29420;
  long int D.29421;
  struct GHashTable * D.29426;
  struct GHashTable * D.29429;
  struct MonoType * D.29432;
  struct MonoImage * D.29434;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.29416 = par->owner;
  if (D.29416 == 0B) goto <D.29413>; else goto <D.29417>;
  <D.29417>:
  D.29418 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.29418 == 0B) goto <D.29413>; else goto <D.29414>;
  <D.29413>:
  iftmp.79 = 1;
  goto <D.29415>;
  <D.29414>:
  iftmp.79 = 0;
  <D.29415>:
  D.29419 = iftmp.79 != 0;
  D.29420 = (long int) D.29419;
  D.29421 = __builtin_expect (D.29420, 0);
  if (D.29421 != 0) goto <D.29422>; else goto <D.29423>;
  <D.29422>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.29423>:
  D.29416 = par->owner;
  if (D.29416 != 0B) goto <D.29424>; else goto <D.29425>;
  <D.29424>:
  D.29416 = par->owner;
  image = D.29416->image;
  mono_image_lock (image);
  D.29426 = image->gsharedvt_types;
  if (D.29426 == 0B) goto <D.29427>; else goto <D.29428>;
  <D.29427>:
  D.29429 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.29429;
  <D.29428>:
  D.29426 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.29426, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.29430>; else goto <D.29431>;
  <D.29430>:
  D.29432 = res;
  return D.29432;
  <D.29431>:
  copy = mono_image_alloc0 (image, 56);
  memcpy (copy, par, 56);
  goto <D.29433>;
  <D.29425>:
  copy = monoeg_g_memdup (par, 56);
  <D.29433>:
  copy->owner = 0B;
  D.29434 = mono_defaults.corlib;
  copy->image = D.29434;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.29416 = par->owner;
  if (D.29416 != 0B) goto <D.29435>; else goto <D.29436>;
  <D.29435>:
  mono_image_lock (image);
  D.29426 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.29426, par, res, 0);
  mono_image_unlock (image);
  <D.29436>:
  D.29432 = res;
  return D.29432;
}


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

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


mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.29440;
  <unnamed-unsigned:22> D.29443;
  long unsigned int D.29444;
  long unsigned int D.29445;
  void * D.29446;
  unsigned char D.29449;
  struct MonoGenericParam * D.29451;
  short unsigned int D.29452;
  gboolean * D.29455;
  long unsigned int D.29456;
  long unsigned int D.29457;
  gboolean * D.29458;
  int D.29459;
  struct MonoGenericInst * D.29460;
  void * D.29463;
  unsigned char D.29466;
  struct MonoGenericParam * D.29468;
  short unsigned int D.29469;
  gboolean * D.29472;
  gboolean * D.29473;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 16);
  D.29440 = context->class_inst;
  if (D.29440 != 0B) goto <D.29441>; else goto <D.29442>;
  <D.29441>:
  inst = context->class_inst;
  D.29443 = inst->type_argc;
  D.29444 = (long unsigned int) D.29443;
  D.29445 = D.29444 * 4;
  D.29446 = monoeg_malloc0 (D.29445);
  gsctx->var_is_vt = D.29446;
  i = 0;
  goto <D.26414>;
  <D.26413>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29449 = type->type;
    if (D.29449 == 19) goto <D.29447>; else goto <D.29450>;
    <D.29450>:
    D.29449 = type->type;
    if (D.29449 == 30) goto <D.29447>; else goto <D.29448>;
    <D.29447>:
    D.29451 = type->data.generic_param;
    D.29452 = D.29451->serial;
    if (D.29452 == 1) goto <D.29453>; else goto <D.29454>;
    <D.29453>:
    D.29455 = gsctx->var_is_vt;
    D.29456 = (long unsigned int) i;
    D.29457 = D.29456 * 4;
    D.29458 = D.29455 + D.29457;
    *D.29458 = 1;
    <D.29454>:
    <D.29448>:
  }
  i = i + 1;
  <D.26414>:
  D.29443 = inst->type_argc;
  D.29459 = (int) D.29443;
  if (D.29459 > i) goto <D.26413>; else goto <D.26415>;
  <D.26415>:
  <D.29442>:
  D.29460 = context->method_inst;
  if (D.29460 != 0B) goto <D.29461>; else goto <D.29462>;
  <D.29461>:
  inst = context->method_inst;
  D.29443 = inst->type_argc;
  D.29444 = (long unsigned int) D.29443;
  D.29445 = D.29444 * 4;
  D.29463 = monoeg_malloc0 (D.29445);
  gsctx->mvar_is_vt = D.29463;
  i = 0;
  goto <D.26418>;
  <D.26417>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.29466 = type->type;
    if (D.29466 == 19) goto <D.29464>; else goto <D.29467>;
    <D.29467>:
    D.29466 = type->type;
    if (D.29466 == 30) goto <D.29464>; else goto <D.29465>;
    <D.29464>:
    D.29468 = type->data.generic_param;
    D.29469 = D.29468->serial;
    if (D.29469 == 1) goto <D.29470>; else goto <D.29471>;
    <D.29470>:
    D.29472 = gsctx->mvar_is_vt;
    D.29456 = (long unsigned int) i;
    D.29457 = D.29456 * 4;
    D.29473 = D.29472 + D.29457;
    *D.29473 = 1;
    <D.29471>:
    <D.29465>:
  }
  i = i + 1;
  <D.26418>:
  D.29443 = inst->type_argc;
  D.29459 = (int) D.29443;
  if (D.29459 > i) goto <D.26417>; else goto <D.26419>;
  <D.26419>:
  <D.29462>:
}


mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.29474;
  _Bool D.29475;
  unsigned int D.29476;
  _Bool D.29477;
  unsigned int D.29478;
  _Bool D.29479;
  <unnamed type> D.29480;
  unsigned int D.29481;
  int iftmp.80;
  struct MonoClass * D.29492;
  int D.29493;
  unsigned int D.29495;
  long unsigned int D.29497;
  long unsigned int D.29498;
  struct MonoGenericContainer * D.29500;
  struct MonoGenericClass * D.29502;
  int D.29504;
  int iftmp.81;
  int D.29509;
  int D.29512;
  long unsigned int D.29518;
  long unsigned int D.29519;
  int D.29521;
  long unsigned int D.29524;
  long unsigned int D.29525;
  int D.29526;
  int D.29529;
  int D.29536;
  int D.29539;
  _Bool D.29540;
  long int D.29541;
  long int D.29542;
  _Bool D.29550;
  long int D.29551;
  long int D.29552;
  struct MonoMethod * D.29556;
  struct MonoMethodHeader * D.29557;
  struct MonoMemPool * D.29558;
  <unnamed type> D.29559;
  unsigned char D.29560;
  <unnamed-unsigned:1> D.29561;
  int mini_verbose.82;
  unsigned int mini_verbose.83;
  unsigned char D.29564;
  <unnamed-unsigned:1> D.29565;
  unsigned char D.29566;
  <unnamed-unsigned:1> D.29567;
  <unnamed-unsigned:1> D.29568;
  int D.29569;
  unsigned char D.29570;
  <unnamed-unsigned:1> D.29571;
  int D.29572;
  unsigned char D.29573;
  <unnamed-unsigned:1> D.29574;
  int D.29575;
  unsigned char D.29576;
  <unnamed-unsigned:1> D.29577;
  struct MonoGenericSharingContext * D.29580;
  unsigned char D.29581;
  <unnamed-unsigned:1> D.29582;
  struct GHashTable * D.29583;
  long unsigned int D.29584;
  long unsigned int D.29585;
  struct GPtrArray * D.29588;
  long unsigned int D.29591;
  long unsigned int D.29592;
  struct MonoCompile * D.29599;
  struct MonoGenericSharingContext * D.29602;
  int D.29605;
  long unsigned int D.29609;
  _Bool D.29610;
  long int D.29611;
  long int D.29612;
  long unsigned int D.29618;
  long unsigned int D.29619;
  _Bool D.29620;
  long int D.29621;
  long int D.29622;
  _Bool D.29628;
  long int D.29629;
  long int D.29630;
  const char * D.29635;
  gchar * D.29636;
  unsigned char D.29643;
  unsigned int D.29644;
  const char * D.29646;
  gchar * D.29647;
  int D.29650;
  unsigned int D.29653;
  unsigned int D.29654;
  unsigned int D.29655;
  unsigned int D.29656;
  unsigned int D.29657;
  int mono_using_xdebug.84;
  unsigned int D.29663;
  const gchar * D.29664;
  char * D.29670;
  char * D.29672;
  int D.29673;
  int D.26458;
  const gchar * D.29676;
  struct MonoMemPool * D.29679;
  <unnamed-unsigned:15> D.29680;
  unsigned int D.29681;
  unsigned int D.29682;
  void * D.29683;
  unsigned int D.29684;
  const char * iftmp.85;
  int D.29688;
  const char * iftmp.86;
  unsigned int D.29697;
  unsigned int D.29700;
  int count.87;
  int count.88;
  struct MonoExceptionClause * D.29703;
  long unsigned int D.29706;
  long unsigned int D.29707;
  long unsigned int D.29710;
  unsigned int D.29713;
  struct MonoRegState * D.29716;
  long unsigned int D.29717;
  struct MonoRegState * D.29720;
  int D.29721;
  unsigned int D.29722;
  unsigned int D.29723;
  int D.29726;
  struct MonoDebugOptions * D.29729;
  int D.29730;
  unsigned int D.29733;
  unsigned int D.29738;
  _Bool D.29745;
  long int D.29746;
  long int D.29747;
  int D.29752;
  unsigned int D.29753;
  unsigned int D.29754;
  unsigned int D.29755;
  int D.29756;
  struct MonoInst * D.29759;
  unsigned char D.29762;
  unsigned char D.29763;
  long int D.29764;
  struct MonoInst * D.29765;
  int D.29766;
  int D.29767;
  const unsigned char * D.29768;
  int D.29769;
  struct MonoBasicBlock * D.29770;
  struct MonoInst * D.29771;
  unsigned int D.29775;
  unsigned int D.29776;
  unsigned int D.29779;
  unsigned int D.29782;
  unsigned int D.29785;
  unsigned int D.29788;
  unsigned int D.29795;
  unsigned int D.29797;
  unsigned int D.29798;
  void * D.29799;
  struct MonoBasicBlock * D.29800;
  struct MonoBasicBlock * * D.29801;
  int dfn.89;
  int D.29803;
  unsigned int D.29804;
  unsigned int D.29807;
  unsigned int D.29808;
  unsigned int D.29809;
  unsigned int D.29812;
  int D.29817;
  struct MonoInst * D.29818;
  struct MonoBasicBlock * * D.29819;
  struct MonoBasicBlock * D.29820;
  short int D.29821;
  unsigned int D.29824;
  unsigned int D.29828;
  unsigned int D.29829;
  unsigned int D.29838;
  unsigned int D.29839;
  long unsigned int D.29842;
  long unsigned int D.29851;
  long unsigned int D.29852;
  unsigned int D.29863;
  unsigned int D.29864;
  unsigned int D.29867;
  void * D.29876;
  unsigned int D.29888;
  struct MonoInst * D.29891;
  long unsigned int D.29894;
  _Bool D.29895;
  long int D.29896;
  long int D.29897;
  _Bool D.29900;
  long int D.29901;
  long int D.29902;
  void * D.29905;
  long int D.29906;
  long unsigned int D.29907;
  int D.29908;
  long long int D.29909;
  long long unsigned int D.29910;
  long long unsigned int D.29911;
  unsigned int D.29914;
  unsigned int D.29919;
  unsigned int D.29920;
  void * D.29927;
  long int D.29928;
  unsigned int D.29929;
  unsigned int D.29930;
  regmask_t * D.29933;
  int need_local_opts.90;
  struct MonoInst * D.29948;
  short unsigned int D.29951;
  short unsigned int D.29952;
  short unsigned int D.29954;
  short unsigned int D.29956;
  struct MonoBasicBlock * * D.29957;
  struct MonoBasicBlock * * D.29958;
  struct MonoBasicBlock * D.29959;
  struct MonoBasicBlock * D.29962;
  struct MonoInst * D.29972;
  struct MonoInst * D.29974;
  unsigned char D.29975;
  struct MonoBasicBlock * D.29976;
  struct MonoBasicBlock * D.29978;
  unsigned int D.29979;
  unsigned int D.29980;
  short unsigned int D.29981;
  int D.29986;
  unsigned int D.29989;
  struct MonoJitInfo * D.29996;
  unsigned char * D.30001;
  unsigned int D.30002;
  int D.30003;
  char * D.30004;
  struct MonoDomain * D.30007;
  union mono_mutex_t * D.30008;
  _Bool D.30011;
  long int D.30012;
  long int D.30013;
  struct MonoJitInfo * D.30016;
  long unsigned int D.30017;
  struct MonoJitDynamicMethodInfo * D.30020;
  _Bool D.30023;
  long int D.30024;
  long int D.30025;
  struct MonoPerfCounters * mono_perfcounters.91;
  unsigned int D.30029;
  unsigned int D.30030;
  unsigned int D.30031;
  unsigned int D.30032;
  int D.30033;
  unsigned int D.30034;
  unsigned int D.30035;
  int D.30036;
  int D.30037;
  int D.30040;
  char * D.30043;
  const char * D.30044;
  const char * D.30045;
  gchar * D.30046;
  int D.30047;
  unsigned int D.30048;
  unsigned int D.30049;
  int D.30050;
  char * D.30055;
  gchar * D.30056;
  int D.30057;
  unsigned int D.30058;
  unsigned int D.30059;
  int D.30060;
  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.29474 = flags & 1;
      D.29475 = D.29474 != 0;
      run_cctors = (gboolean) D.29475;
      D.29476 = flags & 2;
      D.29477 = D.29476 != 0;
      compile_aot = (gboolean) D.29477;
      D.29478 = flags & 4;
      D.29479 = D.29478 != 0;
      full_aot = (gboolean) D.29479;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.29480 = mono_profiler_get_events ();
      D.29481 = D.29480 & 16;
      if (D.29481 != 0) goto <D.29482>; else goto <D.29483>;
      <D.29482>:
      mono_profiler_method_jit (method);
      <D.29483>:
      if (0 != 0) goto <D.29484>; else goto <D.29485>;
      <D.29484>:
      <D.29485>:
      if (compile_aot != 0) goto <D.29486>; else goto <D.29487>;
      <D.29486>:
      D.29492 = method->klass;
      D.29493 = mono_class_generic_sharing_enabled (D.29492);
      if (D.29493 != 0) goto <D.29494>; else goto <D.29489>;
      <D.29494>:
      D.29495 = opts & 33554432;
      if (D.29495 != 0) goto <D.29496>; else goto <D.29489>;
      <D.29496>:
      D.29497 = BIT_FIELD_REF <*method, 64, 256>;
      D.29498 = D.29497 & 2048;
      if (D.29498 != 0) goto <D.29490>; else goto <D.29499>;
      <D.29499>:
      D.29492 = method->klass;
      D.29500 = D.29492->generic_container;
      if (D.29500 != 0B) goto <D.29490>; else goto <D.29501>;
      <D.29501>:
      D.29492 = method->klass;
      D.29502 = D.29492->generic_class;
      if (D.29502 == 0B) goto <D.29503>; else goto <D.29489>;
      <D.29503>:
      D.29504 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.29504 != 0) goto <D.29490>; else goto <D.29489>;
      <D.29490>:
      iftmp.80 = 1;
      goto <D.29491>;
      <D.29489>:
      iftmp.80 = 0;
      <D.29491>:
      try_generic_shared = iftmp.80;
      goto <D.29505>;
      <D.29487>:
      D.29492 = method->klass;
      D.29509 = mono_class_generic_sharing_enabled (D.29492);
      if (D.29509 != 0) goto <D.29510>; else goto <D.29507>;
      <D.29510>:
      D.29495 = opts & 33554432;
      if (D.29495 != 0) goto <D.29511>; else goto <D.29507>;
      <D.29511>:
      D.29512 = mono_method_is_generic_sharable (method, 0);
      if (D.29512 != 0) goto <D.29513>; else goto <D.29507>;
      <D.29513>:
      iftmp.81 = 1;
      goto <D.29508>;
      <D.29507>:
      iftmp.81 = 0;
      <D.29508>:
      try_generic_shared = iftmp.81;
      <D.29505>:
      D.29495 = opts & 33554432;
      if (D.29495 != 0) goto <D.29514>; else goto <D.29515>;
      <D.29514>:
      if (try_generic_shared != 0) goto <D.29516>; else goto <D.29517>;
      <D.29516>:
      D.29518 = mono_stats.generics_sharable_methods;
      D.29519 = D.29518 + 1;
      mono_stats.generics_sharable_methods = D.29519;
      goto <D.29520>;
      <D.29517>:
      D.29521 = mono_method_is_generic_impl (method);
      if (D.29521 != 0) goto <D.29522>; else goto <D.29523>;
      <D.29522>:
      D.29524 = mono_stats.generics_unsharable_methods;
      D.29525 = D.29524 + 1;
      mono_stats.generics_unsharable_methods = D.29525;
      <D.29523>:
      <D.29520>:
      <D.29515>:
      D.29526 = mini_is_gsharedvt_sharable_method (method);
      if (D.29526 != 0) goto <D.29527>; else goto <D.29528>;
      <D.29527>:
      D.29529 = mono_debug_count ();
      if (D.29529 == 0) goto <D.29530>; else goto <D.29531>;
      <D.29530>:
      try_generic_shared = 0;
      <D.29531>:
      if (compile_aot != 0) goto <D.29532>; else goto <D.29533>;
      <D.29532>:
      try_generic_shared = 0;
      <D.29533>:
      <D.29528>:
      D.29536 = is_gsharedvt_method (method);
      if (D.29536 != 0) goto <D.29534>; else goto <D.29537>;
      <D.29537>:
      if (compile_aot != 0) goto <D.29538>; else goto <D.29535>;
      <D.29538>:
      D.29539 = is_open_method (method);
      if (D.29539 != 0) goto <D.29534>; else goto <D.29535>;
      <D.29534>:
      method_is_gshared = 1;
      D.29540 = compile_aot == 0;
      D.29541 = (long int) D.29540;
      D.29542 = __builtin_expect (D.29541, 0);
      if (D.29542 != 0) goto <D.29543>; else goto <D.29544>;
      <D.29543>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.29544>:
      try_generic_shared = 1;
      <D.29535>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.29545>; else goto <D.29546>;
      <D.29545>:
      method_to_compile = method;
      goto <D.29547>;
      <D.29546>:
      if (try_generic_shared != 0) goto <D.29548>; else goto <D.29549>;
      <D.29548>:
      method_to_compile = mini_get_shared_method (method);
      D.29550 = method_to_compile == 0B;
      D.29551 = (long int) D.29550;
      D.29552 = __builtin_expect (D.29551, 0);
      if (D.29552 != 0) goto <D.29553>; else goto <D.29554>;
      <D.29553>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4898, "method_to_compile");
      <D.29554>:
      goto <D.29555>;
      <D.29549>:
      method_to_compile = method;
      <D.29555>:
      <D.29547>:
      cfg = monoeg_malloc0 (1104);
      cfg->method = method_to_compile;
      D.29556 = cfg->method;
      D.29557 = mono_method_get_header (D.29556);
      cfg->header = D.29557;
      D.29558 = mono_mempool_new ();
      cfg->mempool = D.29558;
      cfg->opt = opts;
      D.29559 = mono_profiler_get_events ();
      cfg->prof_options = D.29559;
      D.29560 = (unsigned char) run_cctors;
      D.29561 = (<unnamed-unsigned:1>) D.29560;
      cfg->run_cctors = D.29561;
      cfg->domain = domain;
      mini_verbose.82 = mini_verbose;
      mini_verbose.83 = (unsigned int) mini_verbose.82;
      cfg->verbose_level = mini_verbose.83;
      D.29564 = (unsigned char) compile_aot;
      D.29565 = (<unnamed-unsigned:1>) D.29564;
      cfg->compile_aot = D.29565;
      D.29566 = (unsigned char) full_aot;
      D.29567 = (<unnamed-unsigned:1>) D.29566;
      cfg->full_aot = D.29567;
      D.29568 = method->skip_visibility;
      cfg->skip_visibility = D.29568;
      cfg->orig_method = method;
      D.29569 = debug_options.gen_seq_points;
      D.29570 = (unsigned char) D.29569;
      D.29571 = (<unnamed-unsigned:1>) D.29570;
      cfg->gen_seq_points = D.29571;
      D.29572 = debug_options.explicit_null_checks;
      D.29573 = (unsigned char) D.29572;
      D.29574 = (<unnamed-unsigned:1>) D.29573;
      cfg->explicit_null_checks = D.29574;
      D.29575 = debug_options.soft_breakpoints;
      D.29576 = (unsigned char) D.29575;
      D.29577 = (<unnamed-unsigned:1>) D.29576;
      cfg->soft_breakpoints = D.29577;
      if (try_generic_shared != 0) goto <D.29578>; else goto <D.29579>;
      <D.29578>:
      D.29580 = &cfg->gsctx;
      cfg->generic_sharing_context = D.29580;
      <D.29579>:
      D.29581 = (unsigned char) try_llvm;
      D.29582 = (<unnamed-unsigned:1>) D.29581;
      cfg->compile_llvm = D.29582;
      D.29583 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.29583;
      D.29584 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.29585 = D.29584 & 32;
      if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
      <D.29586>:
      D.29588 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.29588;
      <D.29587>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29592 = D.29591 & 274877906944;
      if (D.29592 != 0) goto <D.29593>; else goto <D.29594>;
      <D.29593>:
      if (try_generic_shared == 0) goto <D.29595>; else goto <D.29596>;
      <D.29595>:
      D.29497 = BIT_FIELD_REF <*method, 64, 256>;
      D.29498 = D.29497 & 2048;
      if (D.29498 != 0) goto <D.29589>; else goto <D.29597>;
      <D.29597>:
      D.29492 = method->klass;
      D.29500 = D.29492->generic_container;
      if (D.29500 != 0B) goto <D.29589>; else goto <D.29598>;
      <D.29598>:
      if (method_is_gshared != 0) goto <D.29589>; else goto <D.29590>;
      <D.29589>:
      cfg->exception_type = 11;
      D.29599 = cfg;
      return D.29599;
      <D.29590>:
      <D.29596>:
      <D.29594>:
      D.29602 = cfg->generic_sharing_context;
      if (D.29602 != 0B) goto <D.29603>; else goto <D.29604>;
      <D.29603>:
      D.29605 = mini_is_gsharedvt_sharable_method (method);
      if (D.29605 != 0) goto <D.29600>; else goto <D.29606>;
      <D.29606>:
      if (method_is_gshared != 0) goto <D.29600>; else goto <D.29601>;
      <D.29600>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.29607>; else goto <D.29608>;
        <D.29607>:
        D.29497 = BIT_FIELD_REF <*method, 64, 256>;
        D.29609 = D.29497 & 4096;
        D.29610 = D.29609 == 0;
        D.29611 = (long int) D.29610;
        D.29612 = __builtin_expect (D.29611, 0);
        if (D.29612 != 0) goto <D.29613>; else goto <D.29614>;
        <D.29613>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.29614>:
        inflated = method;
        context = &inflated->context;
        D.29540 = compile_aot == 0;
        D.29541 = (long int) D.29540;
        D.29542 = __builtin_expect (D.29541, 0);
        if (D.29542 != 0) goto <D.29615>; else goto <D.29616>;
        <D.29615>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.29616>:
        goto <D.29617>;
        <D.29608>:
        D.29618 = BIT_FIELD_REF <*method_to_compile, 64, 256>;
        D.29619 = D.29618 & 4096;
        D.29620 = D.29619 == 0;
        D.29621 = (long int) D.29620;
        D.29622 = __builtin_expect (D.29621, 0);
        if (D.29622 != 0) goto <D.29623>; else goto <D.29624>;
        <D.29623>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.29624>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.29617>:
        D.29580 = &cfg->gsctx;
        mini_init_gsctx (context, D.29580);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.29601>:
      <D.29604>:
      D.29602 = cfg->generic_sharing_context;
      if (D.29602 != 0B) goto <D.29625>; else goto <D.29626>;
      <D.29625>:
      method_to_register = method_to_compile;
      goto <D.29627>;
      <D.29626>:
      D.29628 = method != method_to_compile;
      D.29629 = (long int) D.29628;
      D.29630 = __builtin_expect (D.29629, 0);
      if (D.29630 != 0) goto <D.29631>; else goto <D.29632>;
      <D.29631>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.29632>:
      method_to_register = method;
      <D.29627>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.29556 = cfg->method;
      sig = mono_method_signature_checked (D.29556, &err);
      if (sig == 0B) goto <D.29633>; else goto <D.29634>;
      <D.29633>:
      cfg->exception_type = 7;
      D.29635 = mono_error_get_message (&err);
      D.29636 = monoeg_strdup (D.29635);
      cfg->exception_message = D.29636;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.29637>; else goto <D.29638>;
      <D.29637>:
      <D.29638>:
      D.29599 = cfg;
      return D.29599;
      <D.29634>:
      header = cfg->header;
      if (header == 0B) goto <D.29639>; else goto <D.29640>;
      <D.29639>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.29641>; else goto <D.29642>;
        <D.29641>:
        D.29643 = error->exception_type;
        D.29644 = (unsigned int) D.29643;
        cfg->exception_type = D.29644;
        goto <D.29645>;
        <D.29642>:
        cfg->exception_type = 3;
        D.29556 = cfg->method;
        D.29646 = D.29556->name;
        D.29647 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.29646);
        cfg->exception_message = D.29647;
        <D.29645>:
        if (0 != 0) goto <D.29648>; else goto <D.29649>;
        <D.29648>:
        <D.29649>:
        D.29599 = cfg;
        return D.29599;
      }
      <D.29640>:
      D.29650 = debug_options.mdb_optimizations;
      if (D.29650 != 0) goto <D.29651>; else goto <D.29652>;
      <D.29651>:
      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.29653 = cfg->opt;
      D.29654 = D.29653 & 4294967231;
      cfg->opt = D.29654;
      D.29653 = cfg->opt;
      D.29655 = D.29653 & 4294967291;
      cfg->opt = D.29655;
      D.29653 = cfg->opt;
      D.29656 = D.29653 & 4294967263;
      cfg->opt = D.29656;
      D.29653 = cfg->opt;
      D.29657 = D.29653 & 4294967279;
      cfg->opt = D.29657;
      cfg->disable_out_of_line_bblocks = 1;
      <D.29652>:
      mono_using_xdebug.84 = mono_using_xdebug;
      if (mono_using_xdebug.84 != 0) goto <D.29659>; else goto <D.29660>;
      <D.29659>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.29660>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.29661>; else goto <D.29662>;
      <D.29661>:
      D.29653 = cfg->opt;
      D.29663 = D.29653 | 262144;
      cfg->opt = D.29663;
      <D.29662>:
      D.29664 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.29664 != 0B) goto <D.29665>; else goto <D.29666>;
      <D.29665>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.29670 = __builtin_strchr (name, 46);
        if (D.29670 > name) goto <D.29667>; else goto <D.29671>;
        <D.29671>:
        D.29672 = __builtin_strchr (name, 58);
        if (D.29672 != 0B) goto <D.29667>; else goto <D.29668>;
        <D.29667>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.29556 = cfg->method;
          D.29673 = mono_method_desc_full_match (desc, D.29556);
          if (D.29673 != 0) goto <D.29674>; else goto <D.29675>;
          <D.29674>:
          cfg->verbose_level = 4;
          <D.29675>:
          mono_method_desc_free (desc);
        }
        goto <D.29669>;
        <D.29668>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29556 = cfg->method;
          D.29646 = D.29556->name;
          D.29676 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
          D.26458 = __builtin_strcmp (D.29646, D.29676);
        }
        if (D.26458 == 0) goto <D.29677>; else goto <D.29678>;
        <D.29677>:
        cfg->verbose_level = 4;
        <D.29678>:
        <D.29669>:
      }
      <D.29666>:
      ip = header->code;
      D.29679 = cfg->mempool;
      D.29680 = header->max_stack;
      D.29681 = (unsigned int) D.29680;
      D.29682 = D.29681 * 16;
      D.29683 = mono_mempool_alloc0 (D.29679, D.29682);
      cfg->intvars = D.29683;
      D.29684 = cfg->verbose_level;
      if (D.29684 != 0) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.29688 = cfg->gsharedvt;
        if (D.29688 != 0) goto <D.29689>; else goto <D.29690>;
        <D.29689>:
        iftmp.85 = "gsharedvt ";
        goto <D.29691>;
        <D.29690>:
        iftmp.85 = "";
        <D.29691>:
        D.29602 = cfg->generic_sharing_context;
        if (D.29602 != 0B) goto <D.29695>; else goto <D.29693>;
        <D.29695>:
        D.29688 = cfg->gsharedvt;
        if (D.29688 == 0) goto <D.29696>; else goto <D.29693>;
        <D.29696>:
        iftmp.86 = "gshared ";
        goto <D.29694>;
        <D.29693>:
        iftmp.86 = "";
        <D.29694>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.85, iftmp.86, method_name);
        monoeg_g_free (method_name);
      }
      <D.29686>:
      D.29653 = cfg->opt;
      D.29697 = D.29653 & 786432;
      if (D.29697 != 0) goto <D.29698>; else goto <D.29699>;
      <D.29698>:
      D.29653 = cfg->opt;
      D.29700 = D.29653 | 2097152;
      cfg->opt = D.29700;
      <D.29699>:
      {
        static int count = 0;

        count.87 = count;
        count.88 = count.87 + 1;
        count = count.88;
      }
      D.29703 = header->clauses;
      if (D.29703 != 0B) goto <D.29704>; else goto <D.29705>;
      <D.29704>:
      cfg->globalra = 0;
      <D.29705>:
      D.29556 = cfg->method;
      D.29706 = BIT_FIELD_REF <*D.29556, 64, 256>;
      D.29707 = D.29706 & 124;
      if (D.29707 == 20) goto <D.29708>; else goto <D.29709>;
      <D.29708>:
      cfg->globalra = 0;
      <D.29709>:
      D.29556 = cfg->method;
      D.29706 = BIT_FIELD_REF <*D.29556, 64, 256>;
      D.29710 = D.29706 & 256;
      if (D.29710 != 0) goto <D.29711>; else goto <D.29712>;
      <D.29711>:
      cfg->globalra = 0;
      <D.29712>:
      D.29713 = header->code_size;
      if (D.29713 > 5000) goto <D.29714>; else goto <D.29715>;
      <D.29714>:
      cfg->globalra = 0;
      <D.29715>:
      D.29716 = mono_regstate_new ();
      cfg->rs = D.29716;
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29717 = D.29591 & 17592186044416;
      if (D.29717 != 0) goto <D.29718>; else goto <D.29719>;
      <D.29718>:
      D.29720 = cfg->rs;
      D.29720->next_vreg = 64;
      <D.29719>:
      D.29720 = cfg->rs;
      D.29721 = D.29720->next_vreg;
      D.29722 = (unsigned int) D.29721;
      cfg->next_vreg = D.29722;
      D.29653 = cfg->opt;
      D.29723 = D.29653 & 2097152;
      if (D.29723 != 0) goto <D.29724>; else goto <D.29725>;
      <D.29724>:
      cfg->enable_extended_bblocks = 0;
      <D.29725>:
      D.29556 = cfg->method;
      D.29726 = mono_compile_is_broken (cfg, D.29556, 1);
      if (D.29726 != 0) goto <D.29727>; else goto <D.29728>;
      <D.29727>:
      D.29729 = mini_get_debug_options ();
      D.29730 = D.29729->break_on_unverified;
      if (D.29730 != 0) goto <D.29731>; else goto <D.29732>;
      <D.29731>:
      raise (5);
      <D.29732>:
      D.29599 = cfg;
      return D.29599;
      <D.29728>:
      mono_compile_create_vars (cfg);
      D.29653 = cfg->opt;
      D.29733 = D.29653 & 4294443007;
      cfg->opt = D.29733;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.29734>; else goto <D.29735>;
      <D.29734>:
      if (try_generic_shared != 0) goto <D.29736>; else goto <D.29737>;
      <D.29736>:
      D.29738 = cfg->exception_type;
      if (D.29738 == 11) goto <D.29739>; else goto <D.29740>;
      <D.29739>:
      if (compile_aot != 0) goto <D.29741>; else goto <D.29742>;
      <D.29741>:
      if (0 != 0) goto <D.29743>; else goto <D.29744>;
      <D.29743>:
      <D.29744>:
      D.29599 = cfg;
      return D.29599;
      <D.29742>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.29740>:
      <D.29737>:
      D.29738 = cfg->exception_type;
      D.29745 = D.29738 == 11;
      D.29746 = (long int) D.29745;
      D.29747 = __builtin_expect (D.29746, 0);
      if (D.29747 != 0) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.29749>:
      if (0 != 0) goto <D.29750>; else goto <D.29751>;
      <D.29750>:
      <D.29751>:
      D.29599 = cfg;
      return D.29599;
      <D.29735>:
      D.29752 = cfg->stat_basic_blocks;
      D.29753 = (unsigned int) D.29752;
      D.29754 = cfg->num_bblocks;
      D.29755 = D.29753 + D.29754;
      D.29756 = (int) D.29755;
      cfg->stat_basic_blocks = D.29756;
      if (0 != 0) goto <D.29757>; else goto <D.29758>;
      <D.29757>:
      {
        struct MonoInst * ins;

        D.29653 = cfg->opt;
        D.29700 = D.29653 | 2097152;
        cfg->opt = D.29700;
        D.29759 = cfg->ret;
        if (D.29759 != 0B) goto <D.29760>; else goto <D.29761>;
        <D.29760>:
        D.29759 = cfg->ret;
        D.29759 = cfg->ret;
        D.29762 = D.29759->flags;
        D.29763 = D.29762 & 251;
        D.29759->flags = D.29763;
        D.29679 = cfg->mempool;
        ins = mono_mempool_alloc (D.29679, 80);
        ins->data.op[1].const_val = 0;
        D.29764 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29764;
        ins->prev = 0B;
        D.29765 = ins->prev;
        ins->next = D.29765;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29766 = ins->sreg3;
        ins->sreg2 = D.29766;
        D.29767 = ins->sreg2;
        ins->sreg1 = D.29767;
        D.29768 = cfg->ip;
        ins->cil_code = D.29768;
        D.29759 = cfg->ret;
        D.29769 = D.29759->dreg;
        ins->sreg1 = D.29769;
        D.29770 = cfg->bb_exit;
        D.29771 = D.29770->last_ins;
        if (D.29771 != 0B) goto <D.29772>; else goto <D.29773>;
        <D.29772>:
        D.29770 = cfg->bb_exit;
        D.29771 = D.29770->last_ins;
        D.29771->next = ins;
        D.29770 = cfg->bb_exit;
        D.29771 = D.29770->last_ins;
        ins->prev = D.29771;
        D.29770 = cfg->bb_exit;
        D.29770->last_ins = ins;
        goto <D.29774>;
        <D.29773>:
        D.29770 = cfg->bb_exit;
        D.29770 = cfg->bb_exit;
        D.29770->last_ins = ins;
        D.29771 = D.29770->last_ins;
        D.29770->code = D.29771;
        <D.29774>:
        <D.29761>:
        D.29653 = cfg->opt;
        D.29775 = D.29653 & 4294967167;
        cfg->opt = D.29775;
        D.29653 = cfg->opt;
        D.29776 = D.29653 & 4294967293;
        cfg->opt = D.29776;
      }
      <D.29758>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.29777>; else goto <D.29778>;
      <D.29777>:
      mono_decompose_long_opts (cfg);
      <D.29778>:
      D.29653 = cfg->opt;
      D.29779 = D.29653 & 48;
      if (D.29779 != 0) goto <D.29780>; else goto <D.29781>;
      <D.29780>:
      mono_local_cprop (cfg);
      <D.29781>:
      D.29653 = cfg->opt;
      D.29782 = D.29653 & 2;
      if (D.29782 != 0) goto <D.29783>; else goto <D.29784>;
      <D.29783>:
      mono_optimize_branches (cfg);
      <D.29784>:
      mono_handle_global_vregs (cfg);
      D.29653 = cfg->opt;
      D.29785 = D.29653 & 64;
      if (D.29785 != 0) goto <D.29786>; else goto <D.29787>;
      <D.29786>:
      mono_local_deadce (cfg);
      <D.29787>:
      D.29653 = cfg->opt;
      D.29788 = D.29653 & 268435456;
      if (D.29788 != 0) goto <D.29789>; else goto <D.29790>;
      <D.29789>:
      mono_local_alias_analysis (cfg);
      <D.29790>:
      if (1 != 0) goto <D.29791>; else goto <D.29792>;
      <D.29791>:
      mono_if_conversion (cfg);
      <D.29792>:
      D.29653 = cfg->opt;
      D.29795 = D.29653 & 524288;
      if (D.29795 != 0) goto <D.29793>; else goto <D.29796>;
      <D.29796>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29717 = D.29591 & 17592186044416;
      if (D.29717 != 0) goto <D.29793>; else goto <D.29794>;
      <D.29793>:
      mono_remove_critical_edges (cfg);
      <D.29794>:
      D.29679 = cfg->mempool;
      D.29754 = cfg->num_bblocks;
      D.29797 = D.29754 + 1;
      D.29798 = D.29797 * 8;
      D.29799 = mono_mempool_alloc (D.29679, D.29798);
      cfg->bblocks = D.29799;
      D.29754 = cfg->num_bblocks;
      cfg->max_block_num = D.29754;
      dfn = 0;
      D.29800 = cfg->bb_entry;
      D.29801 = cfg->bblocks;
      df_visit (D.29800, &dfn, D.29801);
      D.29754 = cfg->num_bblocks;
      dfn.89 = dfn;
      D.29803 = dfn.89 + 1;
      D.29804 = (unsigned int) D.29803;
      if (D.29754 != D.29804) goto <D.29805>; else goto <D.29806>;
      <D.29805>:
      {
        struct MonoBasicBlock * bb;

        dfn.89 = dfn;
        D.29803 = dfn.89 + 1;
        D.29804 = (unsigned int) D.29803;
        cfg->num_bblocks = D.29804;
        bb = cfg->bb_entry;
        goto <D.26464>;
        <D.26463>:
        D.29807 = bb->flags;
        D.29808 = D.29807 & 4294967294;
        bb->flags = D.29808;
        bb = bb->next_bb;
        <D.26464>:
        if (bb != 0B) goto <D.26463>; else goto <D.26465>;
        <D.26465>:
        D.29800 = cfg->bb_entry;
        compute_reachable (D.29800);
        bb = cfg->bb_entry;
        goto <D.26467>;
        <D.26466>:
        D.29807 = bb->flags;
        D.29809 = D.29807 & 16;
        if (D.29809 != 0) goto <D.29810>; else goto <D.29811>;
        <D.29810>:
        compute_reachable (bb);
        <D.29811>:
        bb = bb->next_bb;
        <D.26467>:
        if (bb != 0B) goto <D.26466>; else goto <D.26468>;
        <D.26468>:
        bb = cfg->bb_entry;
        goto <D.26473>;
        <D.26472>:
        D.29807 = bb->flags;
        D.29812 = D.29807 & 1;
        if (D.29812 == 0) goto <D.29813>; else goto <D.29814>;
        <D.29813>:
        D.29684 = cfg->verbose_level;
        if (D.29684 > 1) goto <D.29815>; else goto <D.29816>;
        <D.29815>:
        D.29817 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.29817);
        <D.29816>:
        bb->last_ins = 0B;
        D.29818 = bb->last_ins;
        bb->code = D.29818;
        goto <D.26470>;
        <D.26469>:
        D.29819 = bb->out_bb;
        D.29820 = *D.29819;
        mono_unlink_bblock (cfg, bb, D.29820);
        <D.26470>:
        D.29821 = bb->out_count;
        if (D.29821 != 0) goto <D.26469>; else goto <D.26471>;
        <D.26471>:
        <D.29814>:
        bb = bb->next_bb;
        <D.26473>:
        if (bb != 0B) goto <D.26472>; else goto <D.26474>;
        <D.26474>:
        bb = cfg->bb_entry;
        goto <D.26476>;
        <D.26475>:
        D.29807 = bb->flags;
        D.29808 = D.29807 & 4294967294;
        bb->flags = D.29808;
        bb = bb->next_bb;
        <D.26476>:
        if (bb != 0B) goto <D.26475>; else goto <D.26477>;
        <D.26477>:
      }
      <D.29806>:
      D.29824 = cfg->num_varinfo;
      if (D.29824 > 2000) goto <D.29822>; else goto <D.29825>;
      <D.29825>:
      D.29754 = cfg->num_bblocks;
      if (D.29754 > 1000) goto <D.29822>; else goto <D.29823>;
      <D.29822>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29592 = D.29591 & 274877906944;
      if (D.29592 == 0) goto <D.29826>; else goto <D.29827>;
      <D.29826>:
      D.29653 = cfg->opt;
      D.29828 = D.29653 & 4294967119;
      cfg->opt = D.29828;
      cfg->disable_ssa = 1;
      <D.29827>:
      <D.29823>:
      D.29653 = cfg->opt;
      D.29829 = D.29653 & 8192;
      if (D.29829 != 0) goto <D.29830>; else goto <D.29831>;
      <D.29830>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.29831>:
      if (parts == 1) goto <D.29832>; else goto <D.29833>;
      <D.29832>:
      if (0 != 0) goto <D.29834>; else goto <D.29835>;
      <D.29834>:
      <D.29835>:
      D.29599 = cfg;
      return D.29599;
      <D.29833>:
      D.29653 = cfg->opt;
      D.29723 = D.29653 & 2097152;
      if (D.29723 != 0) goto <D.29836>; else goto <D.29837>;
      <D.29836>:
      D.29838 = cfg->comp_done;
      D.29839 = D.29838 & 32;
      if (D.29839 == 0) goto <D.29840>; else goto <D.29841>;
      <D.29840>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29842 = D.29591 & 8589934592;
      if (D.29842 == 0) goto <D.29843>; else goto <D.29844>;
      <D.29843>:
      mono_ssa_compute (cfg);
      D.29684 = cfg->verbose_level;
      if (D.29684 > 1) goto <D.29845>; else goto <D.29846>;
      <D.29845>:
      print_dfn (cfg);
      <D.29846>:
      <D.29844>:
      <D.29841>:
      <D.29837>:
      if (parts == 2) goto <D.29847>; else goto <D.29848>;
      <D.29847>:
      if (0 != 0) goto <D.29849>; else goto <D.29850>;
      <D.29849>:
      <D.29850>:
      D.29599 = cfg;
      return D.29599;
      <D.29848>:
      D.29851 = BIT_FIELD_REF <*cfg, 64, 5312>;
      D.29852 = D.29851 & 48;
      if (D.29852 != 0) goto <D.29853>; else goto <D.29854>;
      <D.29853>:
      D.29838 = cfg->comp_done;
      D.29839 = D.29838 & 32;
      if (D.29839 != 0) goto <D.29855>; else goto <D.29856>;
      <D.29855>:
      mono_ssa_cprop (cfg);
      <D.29856>:
      <D.29854>:
      D.29838 = cfg->comp_done;
      D.29839 = D.29838 & 32;
      if (D.29839 != 0) goto <D.29857>; else goto <D.29858>;
      <D.29857>:
      D.29653 = cfg->opt;
      D.29795 = D.29653 & 524288;
      if (D.29795 != 0) goto <D.29859>; else goto <D.29860>;
      <D.29859>:
      mono_perform_ssapre (cfg);
      <D.29860>:
      D.29653 = cfg->opt;
      D.29785 = D.29653 & 64;
      if (D.29785 != 0) goto <D.29861>; else goto <D.29862>;
      <D.29861>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.29862>:
      D.29863 = cfg->flags;
      D.29864 = D.29863 & 132;
      if (D.29864 != 0) goto <D.29865>; else goto <D.29866>;
      <D.29865>:
      D.29653 = cfg->opt;
      D.29867 = D.29653 & 262144;
      if (D.29867 != 0) goto <D.29868>; else goto <D.29869>;
      <D.29868>:
      mono_perform_abc_removal (cfg);
      <D.29869>:
      <D.29866>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.29653 = cfg->opt;
      D.29785 = D.29653 & 64;
      if (D.29785 != 0) goto <D.29870>; else goto <D.29871>;
      <D.29870>:
      mono_local_deadce (cfg);
      <D.29871>:
      D.29653 = cfg->opt;
      D.29782 = D.29653 & 2;
      if (D.29782 != 0) goto <D.29872>; else goto <D.29873>;
      <D.29872>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29717 = D.29591 & 17592186044416;
        if (D.29717 != 0) goto <D.29874>; else goto <D.29875>;
        <D.29874>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.26480>;
        <D.26479>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.26480>:
        if (bb != 0B) goto <D.26479>; else goto <D.26481>;
        <D.26481>:
        D.29679 = cfg->mempool;
        D.29754 = cfg->num_bblocks;
        D.29797 = D.29754 + 1;
        D.29798 = D.29797 * 8;
        D.29876 = mono_mempool_alloc (D.29679, D.29798);
        cfg->bblocks = D.29876;
        dfn = 0;
        D.29800 = cfg->bb_entry;
        D.29801 = cfg->bblocks;
        df_visit (D.29800, &dfn, D.29801);
        dfn.89 = dfn;
        D.29803 = dfn.89 + 1;
        D.29804 = (unsigned int) D.29803;
        cfg->num_bblocks = D.29804;
        <D.29875>:
      }
      <D.29873>:
      <D.29858>:
      if (0 != 0) goto <D.29877>; else goto <D.29878>;
      <D.29877>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.29653 = cfg->opt;
      D.29867 = D.29653 & 262144;
      if (D.29867 != 0) goto <D.29879>; else goto <D.29880>;
      <D.29879>:
      mono_perform_abc_removal (cfg);
      <D.29880>:
      <D.29878>:
      if (parts == 3) goto <D.29881>; else goto <D.29882>;
      <D.29881>:
      if (0 != 0) goto <D.29883>; else goto <D.29884>;
      <D.29883>:
      <D.29884>:
      D.29599 = cfg;
      return D.29599;
      <D.29882>:
      if (0 != 0) goto <D.29885>; else goto <D.29886>;
      <D.29885>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.29887>;
      <D.29886>:
      mono_decompose_vtype_opts (cfg);
      <D.29887>:
      D.29863 = cfg->flags;
      D.29888 = D.29863 & 256;
      if (D.29888 != 0) goto <D.29889>; else goto <D.29890>;
      <D.29889>:
      mono_decompose_array_access_opts (cfg);
      <D.29890>:
      D.29891 = cfg->got_var;
      if (D.29891 != 0B) goto <D.29892>; else goto <D.29893>;
      <D.29892>:
      {
        struct GList * regs;
        int got_reg;

        D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29894 = D.29591 & 2199023255552;
        D.29895 = D.29894 == 0;
        D.29896 = (long int) D.29895;
        D.29897 = __builtin_expect (D.29896, 0);
        if (D.29897 != 0) goto <D.29898>; else goto <D.29899>;
        <D.29898>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.29899>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29900 = regs == 0B;
        D.29901 = (long int) D.29900;
        D.29902 = __builtin_expect (D.29901, 0);
        if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
        <D.29903>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5473, "regs");
        <D.29904>:
        D.29905 = regs->data;
        D.29906 = (long int) D.29905;
        got_reg = (int) D.29906;
        monoeg_g_list_free (regs);
        D.29891 = cfg->got_var;
        D.29891->opcode = 366;
        D.29891 = cfg->got_var;
        D.29891->dreg = got_reg;
        D.29907 = cfg->used_int_regs;
        D.29891 = cfg->got_var;
        D.29908 = D.29891->dreg;
        D.29909 = 1 << D.29908;
        D.29910 = (long long unsigned int) D.29909;
        D.29911 = D.29907 | D.29910;
        cfg->used_int_regs = D.29911;
      }
      <D.29893>:
      mono_liveness_handle_exception_clauses (cfg);
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29717 = D.29591 & 17592186044416;
      if (D.29717 != 0) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.26486>;
        <D.26485>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.26486>:
        if (bb != 0B) goto <D.26485>; else goto <D.26487>;
        <D.26487>:
        mono_global_regalloc (cfg);
      }
      <D.29913>:
      D.29653 = cfg->opt;
      D.29914 = D.29653 & 128;
      if (D.29914 != 0) goto <D.29915>; else goto <D.29916>;
      <D.29915>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29717 = D.29591 & 17592186044416;
      if (D.29717 == 0) goto <D.29917>; else goto <D.29918>;
      <D.29917>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.29838 = cfg->comp_done;
        D.29919 = D.29838 & 4294967279;
        cfg->comp_done = D.29919;
        D.29838 = cfg->comp_done;
        D.29920 = D.29838 & 16;
        if (D.29920 == 0) goto <D.29921>; else goto <D.29922>;
        <D.29921>:
        mono_analyze_liveness (cfg);
        <D.29922>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.29923>; else goto <D.29924>;
        <D.29923>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.29891 = cfg->got_var;
        if (D.29891 != 0B) goto <D.29925>; else goto <D.29926>;
        <D.29925>:
        l = regs;
        goto <D.26493>;
        <D.26492>:
        D.29927 = l->data;
        D.29928 = (long int) D.29927;
        D.29929 = (unsigned int) D.29928;
        D.29891 = cfg->got_var;
        D.29908 = D.29891->dreg;
        D.29930 = (unsigned int) D.29908;
        if (D.29929 == D.29930) goto <D.29931>; else goto <D.29932>;
        <D.29931>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.26491>;
        <D.29932>:
        l = l->next;
        <D.26493>:
        if (l != 0B) goto <D.26492>; else goto <D.26491>;
        <D.26491>:
        <D.29926>:
        D.29933 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.29933);
        <D.29924>:
      }
      <D.29918>:
      <D.29916>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29717 = D.29591 & 17592186044416;
      if (D.29717 == 0) goto <D.29934>; else goto <D.29935>;
      <D.29934>:
      mono_arch_allocate_vars (cfg);
      D.29738 = cfg->exception_type;
      if (D.29738 != 0) goto <D.29936>; else goto <D.29937>;
      <D.29936>:
      D.29599 = cfg;
      return D.29599;
      <D.29937>:
      <D.29935>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29717 = D.29591 & 17592186044416;
            if (D.29717 == 0) goto <D.29938>; else goto <D.29939>;
            <D.29938>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.90 = need_local_opts;
            if (need_local_opts.90 != 0) goto <D.29940>; else goto <D.29943>;
            <D.29943>:
            D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29592 = D.29591 & 274877906944;
            if (D.29592 != 0) goto <D.29940>; else goto <D.29941>;
            <D.29940>:
            mono_local_cprop (cfg);
            D.29653 = cfg->opt;
            D.29785 = D.29653 & 64;
            if (D.29785 != 0) goto <D.29944>; else goto <D.29945>;
            <D.29944>:
            mono_local_deadce (cfg);
            <D.29945>:
            <D.29941>:
            <D.29939>:
            bb = cfg->bb_entry;
            goto <D.26499>;
            <D.26498>:
            D.29948 = bb->last_ins;
            if (D.29948 != 0B) goto <D.29949>; else goto <D.29950>;
            <D.29949>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29952 = D.29951 + 64985;
            if (D.29952 <= 9) goto <D.29946>; else goto <D.29953>;
            <D.29953>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29954 = D.29951 + 64878;
            if (D.29954 <= 9) goto <D.29946>; else goto <D.29955>;
            <D.29955>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29956 = D.29951 + 64888;
            if (D.29956 <= 9) goto <D.29946>; else goto <D.29947>;
            <D.29946>:
            D.29948 = bb->last_ins;
            D.29957 = D.29948->data.op[1].many_blocks;
            D.29958 = D.29957 + 8;
            D.29959 = *D.29958;
            if (D.29959 != 0B) goto <D.29960>; else goto <D.29961>;
            <D.29960>:
            D.29962 = bb->next_bb;
            D.29948 = bb->last_ins;
            D.29957 = D.29948->data.op[1].many_blocks;
            D.29958 = D.29957 + 8;
            D.29959 = *D.29958;
            if (D.29962 != D.29959) goto <D.29963>; else goto <D.29964>;
            <D.29963>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29952 = D.29951 + 64985;
            if (D.29952 <= 9) goto <D.29965>; else goto <D.29969>;
            <D.29969>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29954 = D.29951 + 64878;
            if (D.29954 <= 9) goto <D.29965>; else goto <D.29970>;
            <D.29970>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29956 = D.29951 + 64888;
            if (D.29956 <= 9) goto <D.29965>; else goto <D.29966>;
            <D.29965>:
            D.29948 = bb->last_ins;
            D.29951 = D.29948->opcode;
            D.29954 = D.29951 + 64878;
            if (D.29954 > 9) goto <D.29971>; else goto <D.29966>;
            <D.29971>:
            D.29948 = bb->last_ins;
            D.29972 = D.29948->data.op[0].src;
            if (D.29972 == 0B) goto <D.29967>; else goto <D.29973>;
            <D.29973>:
            D.29948 = bb->last_ins;
            D.29972 = D.29948->data.op[0].src;
            D.29974 = D.29972->data.op[0].src;
            D.29975 = D.29974->type;
            if (D.29975 != 4) goto <D.29967>; else goto <D.29966>;
            <D.29967>:
            D.29962 = bb->next_bb;
            D.29948 = bb->last_ins;
            D.29957 = D.29948->data.op[1].many_blocks;
            D.29976 = *D.29957;
            if (D.29962 == D.29976) goto <D.29977>; else goto <D.29966>;
            <D.29977>:
            {
              struct MonoBasicBlock * tmp;

              D.29948 = bb->last_ins;
              D.29957 = D.29948->data.op[1].many_blocks;
              tmp = *D.29957;
              D.29948 = bb->last_ins;
              D.29957 = D.29948->data.op[1].many_blocks;
              D.29948 = bb->last_ins;
              D.29957 = D.29948->data.op[1].many_blocks;
              D.29978 = MEM[(struct MonoBasicBlock * *)D.29957 + 8B];
              *D.29957 = D.29978;
              D.29948 = bb->last_ins;
              D.29957 = D.29948->data.op[1].many_blocks;
              D.29958 = D.29957 + 8;
              *D.29958 = tmp;
              D.29948 = bb->last_ins;
              D.29948 = bb->last_ins;
              D.29951 = D.29948->opcode;
              D.29979 = (unsigned int) D.29951;
              D.29980 = mono_reverse_branch_op (D.29979);
              D.29981 = (short unsigned int) D.29980;
              D.29948->opcode = D.29981;
            }
            goto <D.29968>;
            <D.29966>:
            {
              struct MonoInst * inst;

              D.29679 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.29679, 80);
              inst->opcode = 442;
              D.29948 = bb->last_ins;
              D.29957 = D.29948->data.op[1].many_blocks;
              D.29978 = MEM[(struct MonoBasicBlock * *)D.29957 + 8B];
              inst->data.op[0].target_block = D.29978;
              mono_bblock_add_inst (bb, inst);
            }
            <D.29968>:
            <D.29964>:
            <D.29961>:
            <D.29947>:
            <D.29950>:
            bb = bb->next_bb;
            <D.26499>:
            if (bb != 0B) goto <D.26498>; else goto <D.26500>;
            <D.26500>:
            D.29684 = cfg->verbose_level;
            if (D.29684 > 3) goto <D.29982>; else goto <D.29983>;
            <D.29982>:
            D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29717 = D.29591 & 17592186044416;
            if (D.29717 == 0) goto <D.29984>; else goto <D.29985>;
            <D.29984>:
            bb = cfg->bb_entry;
            goto <D.26507>;
            <D.26506>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.29986 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.29986);
              if (tree == 0B) goto <D.29987>; else goto <D.29988>;
              <D.29987>:
              // predicted unlikely by continue predictor.
              goto <D.26502>;
              <D.29988>:
              goto <D.26504>;
              <D.26503>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.26504>:
              if (tree != 0B) goto <D.26503>; else goto <D.26505>;
              <D.26505>:
            }
            <D.26502>:
            bb = bb->next_bb;
            <D.26507>:
            if (bb != 0B) goto <D.26506>; else goto <D.26508>;
            <D.26508>:
            <D.29985>:
            <D.29983>:
            bb = cfg->bb_entry;
            goto <D.26510>;
            <D.26509>:
            D.29989 = cfg->next_vreg;
            bb->max_vreg = D.29989;
            bb = bb->next_bb;
            <D.26510>:
            if (bb != 0B) goto <D.26509>; else goto <D.26511>;
            <D.26511>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.29990>; else goto <D.29991>;
      <D.29990>:
      goto <D.29992>;
      <D.29991>:
      mono_codegen (cfg);
      <D.29992>:
      if (0 != 0) goto <D.29993>; else goto <D.29994>;
      <D.29993>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.29995>;
      <D.29994>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.29995>:
      D.29996 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.29996;
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29592 = D.29591 & 274877906944;
      if (D.29592 == 0) goto <D.29997>; else goto <D.29998>;
      <D.29997>:
      mono_save_xdebug_info (cfg);
      <D.29998>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.29684 = cfg->verbose_level;
      if (D.29684 > 1) goto <D.29999>; else goto <D.30000>;
      <D.29999>:
      {
        char * id;

        D.29556 = cfg->method;
        id = mono_method_full_name (D.29556, 0);
        D.30001 = cfg->native_code;
        D.30002 = cfg->code_len;
        D.30003 = (int) D.30002;
        D.30004 = id + 3;
        mono_disassemble_code (cfg, D.30001, D.30003, D.30004);
        monoeg_g_free (id);
      }
      <D.30000>:
      D.29591 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29592 = D.29591 & 274877906944;
      if (D.29592 == 0) goto <D.30005>; else goto <D.30006>;
      <D.30005>:
      {
        int ret;

        D.30007 = cfg->domain;
        D.30008 = &D.30007->lock.mutex;
        ret = pthread_mutex_lock (D.30008);
        if (ret != 0) goto <D.30009>; else goto <D.30010>;
        <D.30009>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30010>:
        D.30011 = ret != 0;
        D.30012 = (long int) D.30011;
        D.30013 = __builtin_expect (D.30012, 0);
        if (D.30013 != 0) goto <D.30014>; else goto <D.30015>;
        <D.30014>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.30015>:
      }
      D.30007 = cfg->domain;
      D.30016 = cfg->jit_info;
      mono_jit_info_table_add (D.30007, D.30016);
      D.29556 = cfg->method;
      D.29706 = BIT_FIELD_REF <*D.29556, 64, 256>;
      D.30017 = D.29706 & 512;
      if (D.30017 != 0) goto <D.30018>; else goto <D.30019>;
      <D.30018>:
      D.30007 = cfg->domain;
      D.29556 = cfg->method;
      D.30020 = mono_dynamic_code_hash_lookup (D.30007, D.29556);
      D.30016 = cfg->jit_info;
      D.30020->ji = D.30016;
      <D.30019>:
      {
        int ret;

        D.30007 = cfg->domain;
        D.30008 = &D.30007->lock.mutex;
        ret = pthread_mutex_unlock (D.30008);
        if (ret != 0) goto <D.30021>; else goto <D.30022>;
        <D.30021>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30022>:
        D.30023 = ret != 0;
        D.30024 = (long int) D.30023;
        D.30025 = __builtin_expect (D.30024, 0);
        if (D.30025 != 0) goto <D.30026>; else goto <D.30027>;
        <D.30026>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.30027>:
      }
      <D.30006>:
      mono_perfcounters.91 = mono_perfcounters;
      D.30029 = mono_perfcounters.91->jit_methods;
      D.30030 = D.30029 + 1;
      mono_perfcounters.91->jit_methods = D.30030;
      mono_perfcounters.91 = mono_perfcounters;
      mono_perfcounters.91 = mono_perfcounters;
      D.30031 = mono_perfcounters.91->jit_bytes;
      D.29713 = header->code_size;
      D.30032 = D.30031 + D.29713;
      mono_perfcounters.91->jit_bytes = D.30032;
      D.30033 = mono_jit_stats.allocated_code_size;
      D.30034 = (unsigned int) D.30033;
      D.30002 = cfg->code_len;
      D.30035 = D.30034 + D.30002;
      D.30036 = (int) D.30035;
      mono_jit_stats.allocated_code_size = D.30036;
      D.30002 = cfg->code_len;
      code_size_ratio = (int) D.30002;
      D.30037 = mono_jit_stats.biggest_method_size;
      if (D.30037 < code_size_ratio) goto <D.30038>; else goto <D.30039>;
      <D.30038>:
      D.30040 = mono_jit_stats.enabled;
      if (D.30040 != 0) goto <D.30041>; else goto <D.30042>;
      <D.30041>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.30043 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.30043);
      D.29492 = method->klass;
      D.30044 = D.29492->name;
      D.30045 = method->name;
      D.30046 = monoeg_g_strdup_printf ("%s::%s)", D.30044, D.30045);
      mono_jit_stats.biggest_method = D.30046;
      <D.30042>:
      <D.30039>:
      D.30047 = code_size_ratio * 100;
      D.30048 = (unsigned int) D.30047;
      D.29713 = header->code_size;
      D.30049 = D.30048 / D.29713;
      code_size_ratio = (int) D.30049;
      D.30050 = mono_jit_stats.max_code_size_ratio;
      if (D.30050 < code_size_ratio) goto <D.30051>; else goto <D.30052>;
      <D.30051>:
      D.30040 = mono_jit_stats.enabled;
      if (D.30040 != 0) goto <D.30053>; else goto <D.30054>;
      <D.30053>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.30055 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.30055);
      D.29492 = method->klass;
      D.30044 = D.29492->name;
      D.30045 = method->name;
      D.30056 = monoeg_g_strdup_printf ("%s::%s)", D.30044, D.30045);
      mono_jit_stats.max_ratio_method = D.30056;
      <D.30054>:
      <D.30052>:
      D.30057 = mono_jit_stats.native_code_size;
      D.30058 = (unsigned int) D.30057;
      D.30002 = cfg->code_len;
      D.30059 = D.30058 + D.30002;
      D.30060 = (int) D.30059;
      mono_jit_stats.native_code_size = D.30060;
      if (0 != 0) goto <D.30061>; else goto <D.30062>;
      <D.30061>:
      <D.30062>:
      D.29599 = cfg;
      return D.29599;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  long unsigned int D.30065;
  long unsigned int D.30066;
  gboolean D.30069;
  struct MonoType * D.30072;
  int D.30073;
  <unnamed-unsigned:22> D.30076;
  int D.30077;
  int D.30080;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.30065 = BIT_FIELD_REF <*method, 64, 256>;
  D.30066 = D.30065 & 4096;
  if (D.30066 == 0) goto <D.30067>; else goto <D.30068>;
  <D.30067>:
  D.30069 = 0;
  return D.30069;
  <D.30068>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.30070>; else goto <D.30071>;
  <D.30070>:
  i = 0;
  goto <D.26367>;
  <D.26366>:
  D.30072 = inst->type_argv[i];
  D.30073 = is_gsharedvt_type (D.30072);
  if (D.30073 != 0) goto <D.30074>; else goto <D.30075>;
  <D.30074>:
  D.30069 = 1;
  return D.30069;
  <D.30075>:
  i = i + 1;
  <D.26367>:
  D.30076 = inst->type_argc;
  D.30077 = (int) D.30076;
  if (D.30077 > i) goto <D.26366>; else goto <D.26368>;
  <D.26368>:
  <D.30071>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.30078>; else goto <D.30079>;
  <D.30078>:
  i = 0;
  goto <D.26370>;
  <D.26369>:
  D.30072 = inst->type_argv[i];
  D.30080 = is_gsharedvt_type (D.30072);
  if (D.30080 != 0) goto <D.30081>; else goto <D.30082>;
  <D.30081>:
  D.30069 = 1;
  return D.30069;
  <D.30082>:
  i = i + 1;
  <D.26370>:
  D.30076 = inst->type_argc;
  D.30077 = (int) D.30076;
  if (D.30077 > i) goto <D.26369>; else goto <D.26371>;
  <D.26371>:
  <D.30079>:
  D.30069 = 0;
  return D.30069;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.30084;
  int iftmp.92;
  unsigned char D.30089;
  struct MonoGenericParam * D.30091;
  short unsigned int D.30092;

  D.30089 = t->type;
  if (D.30089 == 19) goto <D.30086>; else goto <D.30090>;
  <D.30090>:
  D.30089 = t->type;
  if (D.30089 == 30) goto <D.30086>; else goto <D.30087>;
  <D.30086>:
  D.30091 = t->data.generic_param;
  D.30092 = D.30091->serial;
  if (D.30092 == 1) goto <D.30093>; else goto <D.30087>;
  <D.30093>:
  iftmp.92 = 1;
  goto <D.30088>;
  <D.30087>:
  iftmp.92 = 0;
  <D.30088>:
  D.30084 = iftmp.92;
  return D.30084;
}


is_open_method (struct MonoMethod * method)
{
  long unsigned int D.30095;
  long unsigned int D.30096;
  gboolean D.30099;
  struct MonoGenericInst * D.30100;
  long unsigned int D.30103;
  long unsigned int D.30104;
  struct MonoGenericInst * D.30107;
  long unsigned int D.30110;
  long unsigned int D.30111;
  struct MonoGenericContext * context;

  D.30095 = BIT_FIELD_REF <*method, 64, 256>;
  D.30096 = D.30095 & 4096;
  if (D.30096 == 0) goto <D.30097>; else goto <D.30098>;
  <D.30097>:
  D.30099 = 0;
  return D.30099;
  <D.30098>:
  context = mono_method_get_context (method);
  D.30100 = context->class_inst;
  if (D.30100 != 0B) goto <D.30101>; else goto <D.30102>;
  <D.30101>:
  D.30100 = context->class_inst;
  D.30103 = BIT_FIELD_REF <*D.30100, 64, 0>;
  D.30104 = D.30103 & 18014398509481984;
  if (D.30104 != 0) goto <D.30105>; else goto <D.30106>;
  <D.30105>:
  D.30099 = 1;
  return D.30099;
  <D.30106>:
  <D.30102>:
  D.30107 = context->method_inst;
  if (D.30107 != 0B) goto <D.30108>; else goto <D.30109>;
  <D.30108>:
  D.30107 = context->method_inst;
  D.30110 = BIT_FIELD_REF <*D.30107, 64, 0>;
  D.30111 = D.30110 & 18014398509481984;
  if (D.30111 != 0) goto <D.30112>; else goto <D.30113>;
  <D.30112>:
  D.30099 = 1;
  return D.30099;
  <D.30113>:
  <D.30109>:
  D.30099 = 0;
  return D.30099;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30115;
  struct MonoType * D.30116;
  int D.30117;
  struct MonoInst * D.30120;
  struct MonoInst * D.30121;
  unsigned char D.30122;
  unsigned char D.30123;
  unsigned int D.30124;
  struct MonoMemPool * D.30127;
  short unsigned int D.30128;
  int D.30129;
  <unnamed-unsigned:1> D.30130;
  int D.30131;
  int D.30132;
  long unsigned int D.30133;
  unsigned int D.30134;
  unsigned int D.30135;
  void * D.30136;
  long unsigned int D.30137;
  long unsigned int D.30138;
  struct MonoInst * * D.30141;
  struct MonoClass * D.30142;
  struct MonoType * D.30143;
  struct MonoInst * D.30144;
  int D.30145;
  long unsigned int D.30146;
  long unsigned int D.30147;
  struct MonoInst * * D.30148;
  struct MonoType * D.30149;
  struct MonoInst * D.30150;
  struct MonoInst * D.30157;
  struct MonoInst * D.30158;
  unsigned int D.30159;
  short unsigned int D.30160;
  unsigned int D.30161;
  unsigned int D.30162;
  void * D.30163;
  struct MonoInst * * D.30166;
  long unsigned int D.30167;
  long unsigned int D.30168;
  struct MonoInst * * D.30169;
  struct MonoType * D.30170;
  struct MonoInst * D.30171;
  int D.30172;
  long unsigned int D.30175;
  long unsigned int D.30176;
  long unsigned int D.30179;
  long unsigned int D.30180;
  struct MonoClass * D.30183;
  struct MonoType * D.30184;
  unsigned char D.30185;
  unsigned char D.30186;
  unsigned char D.30187;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.30115 = cfg->method;
  sig = mono_method_signature (D.30115);
  D.30116 = sig->ret;
  D.30117 = mono_type_is_void (D.30116);
  if (D.30117 == 0) goto <D.30118>; else goto <D.30119>;
  <D.30118>:
  D.30116 = sig->ret;
  D.30120 = mono_compile_create_var (cfg, D.30116, 330);
  cfg->ret = D.30120;
  D.30121 = cfg->ret;
  D.30121 = cfg->ret;
  D.30122 = D.30121->flags;
  D.30123 = D.30122 | 4;
  D.30121->flags = D.30123;
  <D.30119>:
  D.30124 = cfg->verbose_level;
  if (D.30124 > 2) goto <D.30125>; else goto <D.30126>;
  <D.30125>:
  monoeg_g_print ("creating vars\n");
  <D.30126>:
  D.30127 = cfg->mempool;
  D.30128 = sig->param_count;
  D.30129 = (int) D.30128;
  D.30130 = sig->hasthis;
  D.30131 = (int) D.30130;
  D.30132 = D.30129 + D.30131;
  D.30133 = (long unsigned int) D.30132;
  D.30134 = (unsigned int) D.30133;
  D.30135 = D.30134 * 8;
  D.30136 = mono_mempool_alloc0 (D.30127, D.30135);
  cfg->args = D.30136;
  D.30137 = BIT_FIELD_REF <*sig, 64, 64>;
  D.30138 = D.30137 & 18014398509481984;
  if (D.30138 != 0) goto <D.30139>; else goto <D.30140>;
  <D.30139>:
  D.30141 = cfg->args;
  D.30115 = cfg->method;
  D.30142 = D.30115->klass;
  D.30143 = &D.30142->this_arg;
  D.30144 = mono_compile_create_var (cfg, D.30143, 330);
  *D.30141 = D.30144;
  <D.30140>:
  i = 0;
  goto <D.26123>;
  <D.26122>:
  D.30141 = cfg->args;
  D.30130 = sig->hasthis;
  D.30131 = (int) D.30130;
  D.30145 = D.30131 + i;
  D.30146 = (long unsigned int) D.30145;
  D.30147 = D.30146 * 8;
  D.30148 = D.30141 + D.30147;
  D.30149 = sig->params[i];
  D.30150 = mono_compile_create_var (cfg, D.30149, 330);
  *D.30148 = D.30150;
  i = i + 1;
  <D.26123>:
  D.30128 = sig->param_count;
  D.30129 = (int) D.30128;
  if (D.30129 > i) goto <D.26122>; else goto <D.26124>;
  <D.26124>:
  D.30124 = cfg->verbose_level;
  if (D.30124 > 2) goto <D.30151>; else goto <D.30152>;
  <D.30151>:
  D.30121 = cfg->ret;
  if (D.30121 != 0B) goto <D.30153>; else goto <D.30154>;
  <D.30153>:
  printf ("\treturn : ");
  D.30121 = cfg->ret;
  mono_print_ins (D.30121);
  <D.30154>:
  D.30137 = BIT_FIELD_REF <*sig, 64, 64>;
  D.30138 = D.30137 & 18014398509481984;
  if (D.30138 != 0) goto <D.30155>; else goto <D.30156>;
  <D.30155>:
  printf ("\tthis: ");
  D.30141 = cfg->args;
  D.30157 = *D.30141;
  mono_print_ins (D.30157);
  <D.30156>:
  i = 0;
  goto <D.26126>;
  <D.26125>:
  printf ("\targ [%d]: ", i);
  D.30141 = cfg->args;
  D.30130 = sig->hasthis;
  D.30131 = (int) D.30130;
  D.30145 = D.30131 + i;
  D.30146 = (long unsigned int) D.30145;
  D.30147 = D.30146 * 8;
  D.30148 = D.30141 + D.30147;
  D.30158 = *D.30148;
  mono_print_ins (D.30158);
  i = i + 1;
  <D.26126>:
  D.30128 = sig->param_count;
  D.30129 = (int) D.30128;
  if (D.30129 > i) goto <D.26125>; else goto <D.26127>;
  <D.26127>:
  <D.30152>:
  D.30159 = cfg->num_varinfo;
  cfg->locals_start = D.30159;
  D.30127 = cfg->mempool;
  D.30160 = header->num_locals;
  D.30161 = (unsigned int) D.30160;
  D.30162 = D.30161 * 8;
  D.30163 = mono_mempool_alloc0 (D.30127, D.30162);
  cfg->locals = D.30163;
  D.30124 = cfg->verbose_level;
  if (D.30124 > 2) goto <D.30164>; else goto <D.30165>;
  <D.30164>:
  monoeg_g_print ("creating locals\n");
  <D.30165>:
  i = 0;
  goto <D.26129>;
  <D.26128>:
  D.30166 = cfg->locals;
  D.30167 = (long unsigned int) i;
  D.30168 = D.30167 * 8;
  D.30169 = D.30166 + D.30168;
  D.30170 = header->locals[i];
  D.30171 = mono_compile_create_var (cfg, D.30170, 329);
  *D.30169 = D.30171;
  i = i + 1;
  <D.26129>:
  D.30160 = header->num_locals;
  D.30172 = (int) D.30160;
  if (D.30172 > i) goto <D.26128>; else goto <D.26130>;
  <D.26130>:
  D.30124 = cfg->verbose_level;
  if (D.30124 > 2) goto <D.30173>; else goto <D.30174>;
  <D.30173>:
  monoeg_g_print ("locals done\n");
  <D.30174>:
  mono_arch_create_vars (cfg);
  D.30115 = cfg->method;
  D.30175 = BIT_FIELD_REF <*D.30115, 64, 256>;
  D.30176 = D.30175 & 256;
  if (D.30176 != 0) goto <D.30177>; else goto <D.30178>;
  <D.30177>:
  D.30179 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30180 = D.30179 & 144115188075855872;
  if (D.30180 != 0) goto <D.30181>; else goto <D.30182>;
  <D.30181>:
  {
    struct MonoInst * lmf_var;

    D.30183 = mono_defaults.int_class;
    D.30184 = &D.30183->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.30184, 329);
    D.30185 = lmf_var->flags;
    D.30186 = D.30185 | 4;
    lmf_var->flags = D.30186;
    D.30185 = lmf_var->flags;
    D.30187 = D.30185 | 32;
    lmf_var->flags = D.30187;
    cfg->lmf_var = lmf_var;
  }
  <D.30182>:
  <D.30178>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.30188;
  long unsigned int D.30191;
  long unsigned int D.30192;
  struct MonoInst * D.30195;
  short unsigned int D.30198;
  short unsigned int D.30199;
  short unsigned int D.30202;
  short unsigned int D.30205;
  struct MonoMemPool * D.30214;
  long int D.30215;
  struct MonoInst * D.30216;
  int D.30217;
  int D.30218;
  const unsigned char * D.30219;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.26259>;
  <D.26258>:
  D.30188 = bb->next_bb;
  if (D.30188 != 0B) goto <D.30189>; else goto <D.30190>;
  <D.30189>:
  D.30188 = bb->next_bb;
  D.30191 = BIT_FIELD_REF <*D.30188, 64, 1472>;
  D.30192 = D.30191 & 65536;
  if (D.30192 != 0) goto <D.30193>; else goto <D.30194>;
  <D.30193>:
  D.30195 = bb->last_ins;
  if (D.30195 != 0B) goto <D.30196>; else goto <D.30197>;
  <D.30196>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  D.30199 = D.30198 + 64985;
  if (D.30199 > 9) goto <D.30200>; else goto <D.30201>;
  <D.30200>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  D.30202 = D.30198 + 64878;
  if (D.30202 > 9) goto <D.30203>; else goto <D.30204>;
  <D.30203>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  D.30205 = D.30198 + 64888;
  if (D.30205 > 9) goto <D.30206>; else goto <D.30207>;
  <D.30206>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  if (D.30198 != 442) goto <D.30208>; else goto <D.30209>;
  <D.30208>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  if (D.30198 != 759) goto <D.30210>; else goto <D.30211>;
  <D.30210>:
  D.30195 = bb->last_ins;
  D.30198 = D.30195->opcode;
  if (D.30198 != 370) goto <D.30212>; else goto <D.30213>;
  <D.30212>:
  {
    struct MonoInst * ins;

    D.30214 = cfg->mempool;
    ins = mono_mempool_alloc (D.30214, 80);
    ins->data.op[1].const_val = 0;
    D.30215 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30215;
    ins->prev = 0B;
    D.30216 = ins->prev;
    ins->next = D.30216;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30217 = ins->sreg3;
    ins->sreg2 = D.30217;
    D.30218 = ins->sreg2;
    ins->sreg1 = D.30218;
    D.30219 = cfg->ip;
    ins->cil_code = D.30219;
    D.30195 = bb->last_ins;
    if (D.30195 != 0B) goto <D.30220>; else goto <D.30221>;
    <D.30220>:
    D.30195 = bb->last_ins;
    D.30195->next = ins;
    D.30195 = bb->last_ins;
    ins->prev = D.30195;
    bb->last_ins = ins;
    goto <D.30222>;
    <D.30221>:
    bb->last_ins = ins;
    D.30195 = bb->last_ins;
    bb->code = D.30195;
    <D.30222>:
    D.30188 = bb->next_bb;
    ins->data.op[0].target_block = D.30188;
  }
  <D.30213>:
  <D.30211>:
  <D.30209>:
  <D.30207>:
  <D.30204>:
  <D.30201>:
  <D.30197>:
  <D.30194>:
  <D.30190>:
  bb = bb->next_bb;
  <D.26259>:
  if (bb != 0B) goto <D.26258>; else goto <D.26260>;
  <D.26260>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.30223;
  unsigned int D.30224;
  unsigned int D.30227;
  struct MonoBasicBlock * * D.30228;
  long unsigned int D.30229;
  long unsigned int D.30230;
  struct MonoBasicBlock * * D.30231;
  struct MonoBasicBlock * D.30232;
  short int D.30233;
  int D.30234;
  int i;

  D.30223 = bb->flags;
  D.30224 = D.30223 & 1;
  if (D.30224 == 0) goto <D.30225>; else goto <D.30226>;
  <D.30225>:
  D.30223 = bb->flags;
  D.30227 = D.30223 | 1;
  bb->flags = D.30227;
  i = 0;
  goto <D.26251>;
  <D.26250>:
  D.30228 = bb->out_bb;
  D.30229 = (long unsigned int) i;
  D.30230 = D.30229 * 8;
  D.30231 = D.30228 + D.30230;
  D.30232 = *D.30231;
  compute_reachable (D.30232);
  i = i + 1;
  <D.26251>:
  D.30233 = bb->out_count;
  D.30234 = (int) D.30233;
  if (D.30234 > i) goto <D.26250>; else goto <D.26252>;
  <D.26252>:
  <D.30226>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30235;
  struct MonoBasicBlock * * D.30236;
  long unsigned int D.30237;
  long unsigned int D.30238;
  struct MonoBasicBlock * * D.30239;
  int D.30240;
  int D.30241;
  struct MonoBasicBlock * * D.30242;
  long unsigned int D.30243;
  long unsigned int D.30244;
  struct MonoBasicBlock * * D.30245;
  struct MonoBasicBlock * D.30246;
  int D.30247;
  short int D.30248;
  int D.30249;
  struct MonoBasicBlock * * D.30250;
  struct MonoBasicBlock * * D.30251;
  struct MonoBasicBlock * D.30252;
  int D.30253;
  short int D.30254;
  int D.30255;
  int iftmp.93;
  struct MonoBasicBlock * D.30257;
  struct MonoBitSet * D.30263;
  int D.30264;
  long unsigned int D.30265;
  long unsigned int D.30266;
  long unsigned int D.30267;
  int D.30268;
  long unsigned int D.30269;
  long unsigned int D.30270;
  _Bool D.30271;
  long int D.30272;
  long int D.30273;
  guint iftmp.94;
  struct MonoBitSet * D.30282;
  unsigned int i.95;
  unsigned int D.30286;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.30235 = cfg->method;
    method_name = mono_method_full_name (D.30235, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.25718>;
  <D.25717>:
  D.30236 = cfg->bblocks;
  D.30237 = (long unsigned int) i;
  D.30238 = D.30237 * 8;
  D.30239 = D.30236 + D.30238;
  bb = *D.30239;
  code = monoeg_strdup ("\n");
  D.30240 = bb->block_num;
  D.30241 = bb->cil_length;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.30240, i, D.30241, code);
  c = bb->code;
  goto <D.25709>;
  <D.25708>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.25709>:
  if (c != 0B) goto <D.25708>; else goto <D.25710>;
  <D.25710>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.25712>;
  <D.25711>:
  D.30242 = bb->in_bb;
  D.30243 = (long unsigned int) j;
  D.30244 = D.30243 * 8;
  D.30245 = D.30242 + D.30244;
  D.30246 = *D.30245;
  D.30247 = D.30246->block_num;
  monoeg_g_print (" BB%d", D.30247);
  j = j + 1;
  <D.25712>:
  D.30248 = bb->in_count;
  D.30249 = (int) D.30248;
  if (D.30249 > j) goto <D.25711>; else goto <D.25713>;
  <D.25713>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.25715>;
  <D.25714>:
  D.30250 = bb->out_bb;
  D.30243 = (long unsigned int) j;
  D.30244 = D.30243 * 8;
  D.30251 = D.30250 + D.30244;
  D.30252 = *D.30251;
  D.30253 = D.30252->block_num;
  monoeg_g_print (" BB%d", D.30253);
  j = j + 1;
  <D.25715>:
  D.30254 = bb->out_count;
  D.30255 = (int) D.30254;
  if (D.30255 > j) goto <D.25714>; else goto <D.25716>;
  <D.25716>:
  D.30257 = bb->idom;
  if (D.30257 != 0B) goto <D.30258>; else goto <D.30259>;
  <D.30258>:
  D.30257 = bb->idom;
  iftmp.93 = D.30257->block_num;
  goto <D.30260>;
  <D.30259>:
  iftmp.93 = -1;
  <D.30260>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.93);
  D.30257 = bb->idom;
  if (D.30257 != 0B) goto <D.30261>; else goto <D.30262>;
  <D.30261>:
  D.30263 = bb->dominators;
  D.30257 = bb->idom;
  D.30264 = D.30257->dfn;
  D.30265 = (long unsigned int) D.30264;
  D.30266 = D.30265 / 64;
  D.30267 = D.30263->data[D.30266];
  D.30257 = bb->idom;
  D.30264 = D.30257->dfn;
  D.30268 = D.30264 & 63;
  D.30269 = D.30267 >> D.30268;
  D.30270 = D.30269 & 1;
  D.30271 = D.30270 == 0;
  D.30272 = (long int) D.30271;
  D.30273 = __builtin_expect (D.30272, 0);
  if (D.30273 != 0) goto <D.30274>; else goto <D.30275>;
  <D.30274>:
  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.30275>:
  <D.30262>:
  D.30263 = bb->dominators;
  if (D.30263 != 0B) goto <D.30276>; else goto <D.30277>;
  <D.30276>:
  D.30263 = bb->dominators;
  D.30257 = bb->idom;
  if (D.30257 != 0B) goto <D.30279>; else goto <D.30280>;
  <D.30279>:
  D.30257 = bb->idom;
  D.30264 = D.30257->dfn;
  iftmp.94 = (guint) D.30264;
  goto <D.30281>;
  <D.30280>:
  iftmp.94 = 4294967295;
  <D.30281>:
  mono_blockset_print (cfg, D.30263, "\tdominators", iftmp.94);
  <D.30277>:
  D.30282 = bb->dfrontier;
  if (D.30282 != 0B) goto <D.30283>; else goto <D.30284>;
  <D.30283>:
  D.30282 = bb->dfrontier;
  mono_blockset_print (cfg, D.30282, "\tdfrontier", 4294967295);
  <D.30284>:
  monoeg_g_free (code);
  i = i + 1;
  <D.25718>:
  i.95 = (unsigned int) i;
  D.30286 = cfg->num_bblocks;
  if (i.95 < D.30286) goto <D.25717>; else goto <D.25719>;
  <D.25719>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.30287;
  long unsigned int D.30288;
  long unsigned int D.30289;
  struct MonoBasicBlock * * D.30290;
  struct MonoBasicBlock * * D.30291;
  long unsigned int D.30292;
  long unsigned int D.30293;
  struct MonoBasicBlock * * D.30294;
  struct MonoBasicBlock * D.30295;
  int D.30296;
  int D.30299;
  short int D.30300;
  int D.30301;
  int i;

  D.30287 = *dfn;
  D.30288 = (long unsigned int) D.30287;
  D.30289 = D.30288 * 8;
  D.30290 = array + D.30289;
  *D.30290 = start;
  i = 0;
  goto <D.25212>;
  <D.25211>:
  D.30291 = start->out_bb;
  D.30292 = (long unsigned int) i;
  D.30293 = D.30292 * 8;
  D.30294 = D.30291 + D.30293;
  D.30295 = *D.30294;
  D.30296 = D.30295->dfn;
  if (D.30296 != 0) goto <D.30297>; else goto <D.30298>;
  <D.30297>:
  // predicted unlikely by continue predictor.
  goto <D.25210>;
  <D.30298>:
  D.30287 = *dfn;
  D.30299 = D.30287 + 1;
  *dfn = D.30299;
  D.30291 = start->out_bb;
  D.30292 = (long unsigned int) i;
  D.30293 = D.30292 * 8;
  D.30294 = D.30291 + D.30293;
  D.30295 = *D.30294;
  D.30287 = *dfn;
  D.30295->dfn = D.30287;
  D.30291 = start->out_bb;
  D.30292 = (long unsigned int) i;
  D.30293 = D.30292 * 8;
  D.30294 = D.30291 + D.30293;
  D.30295 = *D.30294;
  D.30295->df_parent = start;
  D.30287 = *dfn;
  D.30288 = (long unsigned int) D.30287;
  D.30289 = D.30288 * 8;
  D.30290 = array + D.30289;
  D.30291 = start->out_bb;
  D.30292 = (long unsigned int) i;
  D.30293 = D.30292 * 8;
  D.30294 = D.30291 + D.30293;
  D.30295 = *D.30294;
  *D.30290 = D.30295;
  D.30291 = start->out_bb;
  D.30292 = (long unsigned int) i;
  D.30293 = D.30292 * 8;
  D.30294 = D.30291 + D.30293;
  D.30295 = *D.30294;
  df_visit (D.30295, dfn, array);
  <D.25210>:
  i = i + 1;
  <D.25212>:
  D.30300 = start->out_count;
  D.30301 = (int) D.30300;
  if (D.30301 > i) goto <D.25211>; else goto <D.25213>;
  <D.25213>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30302;
  unsigned int D.30303;

  D.30303 = __sync_add_and_fetch_4 (val, 1);
  D.30302 = (gint32) D.30303;
  return D.30302;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.30305;
  _Bool D.30306;
  long int D.30307;
  long int D.30308;
  struct MonoGenericSharingContext * D.30311;
  long unsigned int D.30315;
  long unsigned int D.30316;
  struct MonoMethod * D.30319;
  short unsigned int D.30320;
  int D.30321;
  int D.30322;
  long unsigned int D.30323;
  long unsigned int D.30324;
  int D.30325;
  struct GSList * D.30328;
  struct MonoBasicBlock * D.30331;
  int D.30332;
  int D.30333;
  struct MonoBasicBlock * * D.30334;
  unsigned int D.30335;
  unsigned int D.30336;
  unsigned int D.30337;
  long unsigned int D.30338;
  long unsigned int D.30339;
  struct MonoBasicBlock * * D.30340;
  _Bool D.30341;
  long int D.30342;
  long int D.30343;
  int D.30346;
  long unsigned int D.30351;
  unsigned int D.30352;
  unsigned int D.30353;
  unsigned int D.30354;
  unsigned int D.30355;
  _Bool D.30356;
  long int D.30357;
  long int D.30358;
  unsigned char D.30361;
  unsigned int D.30366;
  <unnamed-unsigned:15> D.30368;
  long unsigned int D.30369;
  long unsigned int D.30370;
  long unsigned int D.30373;
  long unsigned int D.30374;
  long unsigned int D.30375;
  long unsigned int D.30376;
  long unsigned int D.30377;
  long unsigned int D.30378;
  long unsigned int D.30379;
  long unsigned int D.30380;
  long unsigned int D.30381;
  long unsigned int D.30382;
  long unsigned int D.30383;
  struct MonoDomain * D.30385;
  unsigned int D.30386;
  unsigned int D.30387;
  unsigned int generic_info_size.96;
  unsigned int D.30389;
  unsigned int holes_size.97;
  unsigned int D.30391;
  unsigned int arch_eh_info_size.98;
  unsigned int D.30393;
  unsigned int cas_size.99;
  unsigned int D.30395;
  unsigned int D.30396;
  unsigned char * D.30397;
  unsigned int D.30398;
  int D.30399;
  long unsigned int D.30400;
  unsigned int D.30401;
  unsigned int D.30402;
  unsigned int D.30403;
  _Bool D.30404;
  <unnamed-signed:1> D.30405;
  short unsigned int D.30406;
  <unnamed-unsigned:15> D.30407;
  _Bool D.30412;
  long int D.30413;
  long int D.30414;
  void * D.30419;
  void * D.30421;
  struct MonoGenericSharingContext * D.30422;
  short unsigned int D.30425;
  int D.30426;
  int D.30427;
  struct MonoGenericContext * D.30429;
  struct MonoGenericInst * D.30430;
  struct MonoClass * D.30432;
  long unsigned int D.30433;
  long unsigned int D.30434;
  struct MonoInst * D.30435;
  _Bool D.30436;
  long int D.30437;
  long int D.30438;
  struct MonoGenericContext * D.30445;
  struct MonoGenericInst * D.30446;
  short unsigned int D.30450;
  _Bool D.30451;
  long int D.30452;
  long int D.30453;
  struct MonoInst * * D.30456;
  unsigned int D.30459;
  int D.30460;
  int D.30463;
  long unsigned int D.30464;
  long unsigned int D.30465;
  void * D.30466;
  unsigned int D.30468;
  unsigned int D.30469;
  void * D.30470;
  struct MonoDwarfLocListEntry * D.30471;
  long unsigned int D.30472;
  long unsigned int D.30473;
  struct MonoDwarfLocListEntry * D.30474;
  void * D.30475;
  int D.30478;
  _Bool D.30479;
  long int D.30480;
  long int D.30481;
  unsigned char D.30484;
  int D.30485;
  int D.30489;
  unsigned char D.30490;
  long int D.30494;
  unsigned long D.30495;
  unsigned long D.30496;
  _Bool D.30497;
  long int D.30498;
  long int D.30499;
  int D.30502;
  unsigned char D.30503;
  int D.30504;
  short unsigned int D.30507;
  struct MonoBasicBlock * D.30508;
  int D.30509;
  int D.30510;
  unsigned int D.30511;
  unsigned int D.30512;
  unsigned int D.30513;
  long unsigned int D.30514;
  long unsigned int D.30515;
  struct MonoBasicBlock * * D.30516;
  _Bool D.30517;
  long int D.30518;
  long int D.30519;
  int D.30522;
  int D.30525;
  int D.30526;
  int i.100;
  struct MonoExceptionClause * D.30528;
  long int D.30529;
  struct MonoExceptionClause * D.30530;
  long int D.30531;
  long int D.30532;
  long int D.30533;
  short unsigned int D.30534;
  unsigned int D.30535;
  short unsigned int D.30536;
  short unsigned int D.30537;
  short unsigned int D.30538;
  short unsigned int D.30541;
  int D.30542;
  unsigned int D.30543;
  short unsigned int D.30544;
  int D.30545;
  _Bool D.30546;
  long int D.30547;
  long int D.30548;
  struct MonoJitExceptionInfo * D.30559;
  struct MonoJitExceptionInfo * D.30560;
  long unsigned int D.30562;
  long unsigned int D.30563;
  long unsigned int D.30566;
  long unsigned int D.30567;
  unsigned int D.30568;
  unsigned int D.30569;
  int D.30570;
  gint32 iftmp.101;
  long int D.30574;
  unsigned int D.30576;
  unsigned int D.30579;
  long unsigned int D.30580;
  long unsigned int D.30581;
  struct MonoBasicBlock * * D.30582;
  _Bool D.30583;
  long int D.30584;
  long int D.30585;
  int D.30588;
  sizetype D.30589;
  void * D.30590;
  struct MonoClass * D.30592;
  unsigned int D.30593;
  long unsigned int D.30594;
  long unsigned int D.30595;
  struct MonoBasicBlock * * D.30596;
  _Bool D.30599;
  long int D.30600;
  long int D.30601;
  long unsigned int D.30604;
  long unsigned int D.30605;
  void * D.30608;
  void * D.30609;
  unsigned int D.30610;
  unsigned int D.30611;
  long unsigned int D.30612;
  long unsigned int D.30613;
  struct MonoBasicBlock * * D.30614;
  long unsigned int D.30619;
  long unsigned int D.30620;
  struct MonoBasicBlock * * D.30621;
  int D.30624;
  long unsigned int D.30629;
  long unsigned int D.30630;
  struct MonoBasicBlock * * D.30631;
  struct MonoBasicBlock * D.30634;
  int D.30635;
  int D.30636;
  int D.30637;
  sizetype D.30638;
  struct MonoExceptionClause * D.30639;
  void * D.30642;
  long int D.30647;
  long int D.30648;
  long int D.30649;
  int D.30650;
  int D.30651;
  sizetype D.30652;
  void * D.30653;
  unsigned int D.30656;
  unsigned int D.30657;
  unsigned int D.30658;
  long unsigned int D.30661;
  long unsigned int D.30662;
  struct MonoBasicBlock * * D.30663;
  long unsigned int D.30667;
  long unsigned int D.30668;
  struct MonoBasicBlock * * D.30669;
  int D.30672;
  int D.30675;
  unsigned int D.30677;
  sizetype D.30678;
  void * D.30679;
  int D.30680;
  void * D.30683;
  long int D.30684;
  long int D.30685;
  void * D.30686;
  long int D.30687;
  long int D.30688;
  void * D.30689;
  long int D.30690;
  long int D.30691;
  void * D.30692;
  long int D.30693;
  long int D.30694;
  unsigned int D.30695;
  <unnamed-unsigned:15> D.30696;
  int D.30697;
  guint8 * D.30698;
  unsigned int D.30701;
  unsigned int D.30702;
  struct GSList * D.30704;
  unsigned int info_len.102;
  unsigned int D.30708;
  struct MonoJitInfo * D.30709;
  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.30305 = cfg->method;
  D.30306 = D.30305 != method_to_compile;
  D.30307 = (long int) D.30306;
  D.30308 = __builtin_expect (D.30307, 0);
  if (D.30308 != 0) goto <D.30309>; else goto <D.30310>;
  <D.30309>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.30310>:
  header = cfg->header;
  D.30311 = cfg->generic_sharing_context;
  if (D.30311 != 0B) goto <D.30312>; else goto <D.30313>;
  <D.30312>:
  generic_info_size = 32;
  goto <D.30314>;
  <D.30313>:
  generic_info_size = 0;
  <D.30314>:
  D.30315 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.30316 = D.30315 & 512;
  if (D.30316 != 0) goto <D.30317>; else goto <D.30318>;
  <D.30317>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.30319 = cfg->method_to_register;
    sig = mono_method_signature (D.30319);
    D.30320 = sig->param_count;
    D.30321 = (int) D.30320;
    D.30322 = D.30321 + 1;
    D.30323 = (long unsigned int) D.30322;
    D.30324 = D.30323 * 6;
    arg_info = __builtin_alloca (D.30324);
    D.30311 = cfg->generic_sharing_context;
    D.30320 = sig->param_count;
    D.30321 = (int) D.30320;
    D.30325 = mono_arch_get_argument_info (D.30311, sig, D.30321, arg_info);
    stack_size = (guint32) D.30325;
    if (stack_size != 0) goto <D.30326>; else goto <D.30327>;
    <D.30326>:
    arch_eh_info_size = 4;
    <D.30327>:
  }
  <D.30318>:
  D.30328 = cfg->try_block_holes;
  if (D.30328 != 0B) goto <D.30329>; else goto <D.30330>;
  <D.30329>:
  tmp = cfg->try_block_holes;
  goto <D.26290>;
  <D.26289>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.30331 = hole->basic_block;
    D.30332 = D.30331->native_offset;
    D.30331 = hole->basic_block;
    D.30333 = D.30331->native_length;
    hole_end = D.30332 + D.30333;
    D.30334 = cfg->cil_offset_to_bb;
    D.30335 = ec->try_offset;
    D.30336 = ec->try_len;
    D.30337 = D.30335 + D.30336;
    D.30338 = (long unsigned int) D.30337;
    D.30339 = D.30338 * 8;
    D.30340 = D.30334 + D.30339;
    clause_last_bb = *D.30340;
    D.30341 = clause_last_bb == 0B;
    D.30342 = (long int) D.30341;
    D.30343 = __builtin_expect (D.30342, 0);
    if (D.30343 != 0) goto <D.30344>; else goto <D.30345>;
    <D.30344>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.30345>:
    D.30346 = clause_last_bb->native_offset;
    if (D.30346 != hole_end) goto <D.30347>; else goto <D.30348>;
    <D.30347>:
    num_holes = num_holes + 1;
    <D.30348>:
  }
  tmp = tmp->next;
  <D.26290>:
  if (tmp != 0B) goto <D.26289>; else goto <D.26291>;
  <D.26291>:
  if (num_holes != 0) goto <D.30349>; else goto <D.30350>;
  <D.30349>:
  D.30351 = (long unsigned int) num_holes;
  D.30352 = (unsigned int) D.30351;
  D.30353 = D.30352 * 8;
  D.30354 = D.30353 + 4;
  holes_size = (int) D.30354;
  <D.30350>:
  D.30355 = cfg->verbose_level;
  D.30356 = D.30355 > 3;
  D.30357 = (long int) D.30356;
  D.30358 = __builtin_expect (D.30357, 0);
  if (D.30358 != 0) goto <D.30359>; else goto <D.30360>;
  <D.30359>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.30360>:
  <D.30330>:
  D.30319 = cfg->method_to_register;
  D.30361 = mono_method_has_declsec (D.30319);
  if (D.30361 != 0) goto <D.30362>; else goto <D.30363>;
  <D.30362>:
  cas_size = 4;
  <D.30363>:
  if (0 != 0) goto <D.30364>; else goto <D.30365>;
  <D.30364>:
  D.30366 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.30366;
  goto <D.30367>;
  <D.30365>:
  D.30368 = header->num_clauses;
  num_clauses = (int) D.30368;
  <D.30367>:
  D.30305 = cfg->method;
  D.30369 = BIT_FIELD_REF <*D.30305, 64, 256>;
  D.30370 = D.30369 & 512;
  if (D.30370 != 0) goto <D.30371>; else goto <D.30372>;
  <D.30371>:
  D.30373 = (long unsigned int) num_clauses;
  D.30374 = D.30373 * 40;
  D.30375 = (long unsigned int) generic_info_size;
  D.30376 = D.30374 + D.30375;
  D.30377 = (long unsigned int) holes_size;
  D.30378 = D.30376 + D.30377;
  D.30379 = (long unsigned int) arch_eh_info_size;
  D.30380 = D.30378 + D.30379;
  D.30381 = (long unsigned int) cas_size;
  D.30382 = D.30380 + D.30381;
  D.30383 = D.30382 + 48;
  jinfo = monoeg_malloc0 (D.30383);
  goto <D.30384>;
  <D.30372>:
  D.30385 = cfg->domain;
  D.30373 = (long unsigned int) num_clauses;
  D.30386 = (unsigned int) D.30373;
  D.30387 = D.30386 * 40;
  generic_info_size.96 = (unsigned int) generic_info_size;
  D.30389 = D.30387 + generic_info_size.96;
  holes_size.97 = (unsigned int) holes_size;
  D.30391 = D.30389 + holes_size.97;
  arch_eh_info_size.98 = (unsigned int) arch_eh_info_size;
  D.30393 = D.30391 + arch_eh_info_size.98;
  cas_size.99 = (unsigned int) cas_size;
  D.30395 = D.30393 + cas_size.99;
  D.30396 = D.30395 + 48;
  jinfo = mono_domain_alloc0 (D.30385, D.30396);
  <D.30384>:
  D.30319 = cfg->method_to_register;
  jinfo->d.method = D.30319;
  D.30397 = cfg->native_code;
  jinfo->code_start = D.30397;
  D.30398 = cfg->code_len;
  D.30399 = (int) D.30398;
  jinfo->code_size = D.30399;
  D.30400 = cfg->used_int_regs;
  D.30401 = (unsigned int) D.30400;
  jinfo->used_regs = D.30401;
  D.30402 = cfg->opt;
  D.30403 = D.30402 & 512;
  D.30404 = D.30403 != 0;
  D.30405 = (<unnamed-signed:1>) D.30404;
  jinfo->domain_neutral = D.30405;
  D.30406 = (short unsigned int) num_clauses;
  D.30407 = (<unnamed-unsigned:15>) D.30406;
  jinfo->num_clauses = D.30407;
  if (0 != 0) goto <D.30408>; else goto <D.30409>;
  <D.30408>:
  jinfo->from_llvm = -1;
  <D.30409>:
  D.30311 = cfg->generic_sharing_context;
  if (D.30311 != 0B) goto <D.30410>; else goto <D.30411>;
  <D.30410>:
  {
    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.30412 = gi == 0B;
    D.30413 = (long int) D.30412;
    D.30414 = __builtin_expect (D.30413, 0);
    if (D.30414 != 0) goto <D.30415>; else goto <D.30416>;
    <D.30415>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.30416>:
    D.30305 = cfg->method;
    D.30369 = BIT_FIELD_REF <*D.30305, 64, 256>;
    D.30370 = D.30369 & 512;
    if (D.30370 != 0) goto <D.30417>; else goto <D.30418>;
    <D.30417>:
    D.30419 = monoeg_malloc0 (16);
    gi->generic_sharing_context = D.30419;
    goto <D.30420>;
    <D.30418>:
    D.30385 = cfg->domain;
    D.30421 = mono_domain_alloc0 (D.30385, 16);
    gi->generic_sharing_context = D.30421;
    <D.30420>:
    D.30422 = gi->generic_sharing_context;
    D.30311 = cfg->generic_sharing_context;
    memcpy (D.30422, D.30311, 16);
    D.30425 = method_to_compile->flags;
    D.30426 = (int) D.30425;
    D.30427 = D.30426 & 16;
    if (D.30427 != 0) goto <D.30423>; else goto <D.30428>;
    <D.30428>:
    D.30429 = mini_method_get_context (method_to_compile);
    D.30430 = D.30429->method_inst;
    if (D.30430 != 0B) goto <D.30423>; else goto <D.30431>;
    <D.30431>:
    D.30432 = method_to_compile->klass;
    D.30433 = BIT_FIELD_REF <*D.30432, 64, 256>;
    D.30434 = D.30433 & 8;
    if (D.30434 != 0) goto <D.30423>; else goto <D.30424>;
    <D.30423>:
    D.30435 = cfg->rgctx_var;
    D.30436 = D.30435 == 0B;
    D.30437 = (long int) D.30436;
    D.30438 = __builtin_expect (D.30437, 0);
    if (D.30438 != 0) goto <D.30439>; else goto <D.30440>;
    <D.30439>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.30440>:
    <D.30424>:
    gi->has_this = -1;
    D.30425 = method_to_compile->flags;
    D.30426 = (int) D.30425;
    D.30427 = D.30426 & 16;
    if (D.30427 != 0) goto <D.30441>; else goto <D.30444>;
    <D.30444>:
    D.30445 = mini_method_get_context (method_to_compile);
    D.30446 = D.30445->method_inst;
    if (D.30446 != 0B) goto <D.30441>; else goto <D.30447>;
    <D.30447>:
    D.30432 = method_to_compile->klass;
    D.30433 = BIT_FIELD_REF <*D.30432, 64, 256>;
    D.30434 = D.30433 & 8;
    if (D.30434 != 0) goto <D.30441>; else goto <D.30442>;
    <D.30441>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.30448>; else goto <D.30449>;
    <D.30448>:
    D.30450 = inst->opcode;
    D.30451 = D.30450 != 367;
    D.30452 = (long int) D.30451;
    D.30453 = __builtin_expect (D.30452, 0);
    if (D.30453 != 0) goto <D.30454>; else goto <D.30455>;
    <D.30454>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4378, "inst->opcode == OP_REGOFFSET");
    <D.30455>:
    <D.30449>:
    loclist = cfg->rgctx_loclist;
    goto <D.30443>;
    <D.30442>:
    D.30456 = cfg->args;
    inst = *D.30456;
    loclist = cfg->this_loclist;
    <D.30443>:
    if (loclist != 0B) goto <D.30457>; else goto <D.30458>;
    <D.30457>:
    {
      struct GSList * l;
      int i;

      D.30459 = monoeg_g_slist_length (loclist);
      D.30460 = (int) D.30459;
      gi->nlocs = D.30460;
      D.30305 = cfg->method;
      D.30369 = BIT_FIELD_REF <*D.30305, 64, 256>;
      D.30370 = D.30369 & 512;
      if (D.30370 != 0) goto <D.30461>; else goto <D.30462>;
      <D.30461>:
      D.30463 = gi->nlocs;
      D.30464 = (long unsigned int) D.30463;
      D.30465 = D.30464 * 20;
      D.30466 = monoeg_malloc0 (D.30465);
      gi->locations = D.30466;
      goto <D.30467>;
      <D.30462>:
      D.30385 = cfg->domain;
      D.30463 = gi->nlocs;
      D.30464 = (long unsigned int) D.30463;
      D.30468 = (unsigned int) D.30464;
      D.30469 = D.30468 * 20;
      D.30470 = mono_domain_alloc0 (D.30385, D.30469);
      gi->locations = D.30470;
      <D.30467>:
      i = 0;
      l = loclist;
      goto <D.26298>;
      <D.26297>:
      D.30471 = gi->locations;
      D.30472 = (long unsigned int) i;
      D.30473 = D.30472 * 20;
      D.30474 = D.30471 + D.30473;
      D.30475 = l->data;
      memcpy (D.30474, D.30475, 20);
      i = i + 1;
      l = l->next;
      <D.26298>:
      if (l != 0B) goto <D.26297>; else goto <D.26299>;
      <D.26299>:
    }
    <D.30458>:
    if (0 != 0) goto <D.30476>; else goto <D.30477>;
    <D.30476>:
    D.30478 = cfg->llvm_this_reg;
    D.30479 = D.30478 == -1;
    D.30480 = (long int) D.30479;
    D.30481 = __builtin_expect (D.30480, 0);
    if (D.30481 != 0) goto <D.30482>; else goto <D.30483>;
    <D.30482>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.30483>:
    gi->this_in_reg = 0;
    D.30478 = cfg->llvm_this_reg;
    D.30484 = (unsigned char) D.30478;
    gi->this_reg = D.30484;
    D.30485 = cfg->llvm_this_offset;
    gi->this_offset = D.30485;
    goto <D.30486>;
    <D.30477>:
    D.30450 = inst->opcode;
    if (D.30450 == 366) goto <D.30487>; else goto <D.30488>;
    <D.30487>:
    gi->this_in_reg = -1;
    D.30489 = inst->dreg;
    D.30490 = (unsigned char) D.30489;
    gi->this_reg = D.30490;
    goto <D.30491>;
    <D.30488>:
    D.30450 = inst->opcode;
    D.30451 = D.30450 != 367;
    D.30452 = (long int) D.30451;
    D.30453 = __builtin_expect (D.30452, 0);
    if (D.30453 != 0) goto <D.30492>; else goto <D.30493>;
    <D.30492>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.30493>:
    D.30494 = inst->data.op[0].const_val;
    D.30495 = (unsigned long) D.30494;
    D.30496 = D.30495 + 2147483648;
    D.30497 = D.30496 > 4294967295;
    D.30498 = (long int) D.30497;
    D.30499 = __builtin_expect (D.30498, 0);
    if (D.30499 != 0) goto <D.30500>; else goto <D.30501>;
    <D.30500>:
    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.30501>:
    gi->this_in_reg = 0;
    D.30502 = inst->sreg1;
    D.30503 = (unsigned char) D.30502;
    gi->this_reg = D.30503;
    D.30494 = inst->data.op[0].const_val;
    D.30504 = (int) D.30494;
    gi->this_offset = D.30504;
    <D.30491>:
    <D.30486>:
  }
  <D.30411>:
  if (num_holes != 0) goto <D.30505>; else goto <D.30506>;
  <D.30505>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.30507 = (short unsigned int) num_holes;
    table->num_holes = D.30507;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.26310>;
    <D.26309>:
    {
      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.30508 = hole_data->basic_block;
      D.30509 = D.30508->native_offset;
      D.30508 = hole_data->basic_block;
      D.30510 = D.30508->native_length;
      hole_end = D.30509 + D.30510;
      D.30334 = cfg->cil_offset_to_bb;
      D.30511 = ec->try_offset;
      D.30512 = ec->try_len;
      D.30513 = D.30511 + D.30512;
      D.30514 = (long unsigned int) D.30513;
      D.30515 = D.30514 * 8;
      D.30516 = D.30334 + D.30515;
      clause_last_bb = *D.30516;
      D.30517 = clause_last_bb == 0B;
      D.30518 = (long int) D.30517;
      D.30519 = __builtin_expect (D.30518, 0);
      if (D.30519 != 0) goto <D.30520>; else goto <D.30521>;
      <D.30520>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.30521>:
      D.30522 = clause_last_bb->native_offset;
      if (D.30522 == hole_end) goto <D.30523>; else goto <D.30524>;
      <D.30523>:
      // predicted unlikely by continue predictor.
      goto <D.26308>;
      <D.30524>:
      D.30525 = hole_data->start_offset;
      D.30508 = hole_data->basic_block;
      D.30509 = D.30508->native_offset;
      D.30526 = D.30525 - D.30509;
      start_bb_offset = (guint32) D.30526;
      i.100 = i;
      i = i.100 + 1;
      hole = &table->holes[i.100];
      D.30528 = hole_data->clause;
      D.30529 = (long int) D.30528;
      D.30530 = header->clauses;
      D.30531 = (long int) D.30530;
      D.30532 = D.30529 - D.30531;
      D.30533 = D.30532 /[ex] 32;
      D.30534 = (short unsigned int) D.30533;
      hole->clause = D.30534;
      D.30525 = hole_data->start_offset;
      D.30535 = (unsigned int) D.30525;
      hole->offset = D.30535;
      D.30508 = hole_data->basic_block;
      D.30510 = D.30508->native_length;
      D.30536 = (short unsigned int) D.30510;
      D.30537 = (short unsigned int) start_bb_offset;
      D.30538 = D.30536 - D.30537;
      hole->length = D.30538;
      D.30355 = cfg->verbose_level;
      D.30356 = D.30355 > 3;
      D.30357 = (long int) D.30356;
      D.30358 = __builtin_expect (D.30357, 0);
      if (D.30358 != 0) goto <D.30539>; else goto <D.30540>;
      <D.30539>:
      D.30541 = hole->clause;
      D.30542 = (int) D.30541;
      D.30543 = hole->offset;
      D.30544 = hole->length;
      D.30545 = (int) D.30544;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.30542, D.30543, D.30545);
      <D.30540>:
    }
    <D.26308>:
    tmp = tmp->next;
    <D.26310>:
    if (tmp != 0B) goto <D.26309>; else goto <D.26311>;
    <D.26311>:
    D.30546 = i != num_holes;
    D.30547 = (long int) D.30546;
    D.30548 = __builtin_expect (D.30547, 0);
    if (D.30548 != 0) goto <D.30549>; else goto <D.30550>;
    <D.30549>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.30550>:
  }
  <D.30506>:
  if (arch_eh_info_size != 0) goto <D.30551>; else goto <D.30552>;
  <D.30551>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.30552>:
  if (cas_size != 0) goto <D.30553>; else goto <D.30554>;
  <D.30553>:
  jinfo->has_cas_info = -1;
  <D.30554>:
  if (0 != 0) goto <D.30555>; else goto <D.30556>;
  <D.30555>:
  if (num_clauses != 0) goto <D.30557>; else goto <D.30558>;
  <D.30557>:
  D.30559 = &jinfo->clauses[0];
  D.30560 = cfg->llvm_ex_info;
  D.30373 = (long unsigned int) num_clauses;
  D.30374 = D.30373 * 40;
  memcpy (D.30559, D.30560, D.30374);
  <D.30558>:
  goto <D.30561>;
  <D.30556>:
  D.30562 = BIT_FIELD_REF <*header, 64, 64>;
  D.30563 = D.30562 & 9223090561878065152;
  if (D.30563 != 0) goto <D.30564>; else goto <D.30565>;
  <D.30564>:
  {
    int i;

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

      D.30530 = header->clauses;
      D.30566 = (long unsigned int) i;
      D.30567 = D.30566 * 32;
      ec = D.30530 + D.30567;
      ei = &jinfo->clauses[i];
      D.30568 = ec->flags;
      ei->flags = D.30568;
      D.30569 = ec->handler_offset;
      D.30570 = (int) D.30569;
      exvar = mono_find_exvar_for_offset (cfg, D.30570);
      if (exvar != 0B) goto <D.30572>; else goto <D.30573>;
      <D.30572>:
      D.30574 = exvar->data.op[0].const_val;
      iftmp.101 = (gint32) D.30574;
      goto <D.30575>;
      <D.30573>:
      iftmp.101 = 0;
      <D.30575>:
      ei->exvar_offset = iftmp.101;
      D.30576 = ei->flags;
      if (D.30576 == 1) goto <D.30577>; else goto <D.30578>;
      <D.30577>:
      D.30334 = cfg->cil_offset_to_bb;
      D.30579 = ec->data.filter_offset;
      D.30580 = (long unsigned int) D.30579;
      D.30581 = D.30580 * 8;
      D.30582 = D.30334 + D.30581;
      tblock = *D.30582;
      D.30583 = tblock == 0B;
      D.30584 = (long int) D.30583;
      D.30585 = __builtin_expect (D.30584, 0);
      if (D.30585 != 0) goto <D.30586>; else goto <D.30587>;
      <D.30586>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.30587>:
      D.30397 = cfg->native_code;
      D.30588 = tblock->native_offset;
      D.30589 = (sizetype) D.30588;
      D.30590 = D.30397 + D.30589;
      ei->data.filter = D.30590;
      goto <D.30591>;
      <D.30578>:
      D.30592 = ec->data.catch_class;
      ei->data.catch_class = D.30592;
      <D.30591>:
      D.30334 = cfg->cil_offset_to_bb;
      D.30593 = ec->try_offset;
      D.30594 = (long unsigned int) D.30593;
      D.30595 = D.30594 * 8;
      D.30596 = D.30334 + D.30595;
      tblock = *D.30596;
      D.30583 = tblock == 0B;
      D.30584 = (long int) D.30583;
      D.30585 = __builtin_expect (D.30584, 0);
      if (D.30585 != 0) goto <D.30597>; else goto <D.30598>;
      <D.30597>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.30598>:
      D.30588 = tblock->native_offset;
      D.30599 = D.30588 == 0;
      D.30600 = (long int) D.30599;
      D.30601 = __builtin_expect (D.30600, 0);
      if (D.30601 != 0) goto <D.30602>; else goto <D.30603>;
      <D.30602>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.30603>:
      D.30397 = cfg->native_code;
      D.30588 = tblock->native_offset;
      D.30589 = (sizetype) D.30588;
      D.30590 = D.30397 + D.30589;
      ei->try_start = D.30590;
      D.30604 = BIT_FIELD_REF <*tblock, 64, 1472>;
      D.30605 = D.30604 & 8388608;
      if (D.30605 != 0) goto <D.30606>; else goto <D.30607>;
      <D.30606>:
      D.30608 = ei->try_start;
      D.30609 = D.30608 + 18446744073709551615;
      ei->try_start = D.30609;
      <D.30607>:
      D.30334 = cfg->cil_offset_to_bb;
      D.30593 = ec->try_offset;
      D.30610 = ec->try_len;
      D.30611 = D.30593 + D.30610;
      D.30612 = (long unsigned int) D.30611;
      D.30613 = D.30612 * 8;
      D.30614 = D.30334 + D.30613;
      tblock = *D.30614;
      D.30583 = tblock == 0B;
      D.30584 = (long int) D.30583;
      D.30585 = __builtin_expect (D.30584, 0);
      if (D.30585 != 0) goto <D.30615>; else goto <D.30616>;
      <D.30615>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.30616>:
      D.30588 = tblock->native_offset;
      if (D.30588 == 0) goto <D.30617>; else goto <D.30618>;
      <D.30617>:
      {
        int j;
        int end;

        D.30593 = ec->try_offset;
        D.30610 = ec->try_len;
        D.30611 = D.30593 + D.30610;
        j = (int) D.30611;
        D.30593 = ec->try_offset;
        end = (int) D.30593;
        goto <D.26323>;
        <D.26322>:
        {
          struct MonoBasicBlock * bb;

          D.30334 = cfg->cil_offset_to_bb;
          D.30619 = (long unsigned int) j;
          D.30620 = D.30619 * 8;
          D.30621 = D.30334 + D.30620;
          bb = *D.30621;
          if (bb != 0B) goto <D.30622>; else goto <D.30623>;
          <D.30622>:
          D.30624 = bb->native_offset;
          if (D.30624 != 0) goto <D.30625>; else goto <D.30626>;
          <D.30625>:
          tblock = bb;
          goto <D.26321>;
          <D.30626>:
          <D.30623>:
        }
        j = j + -1;
        <D.26323>:
        if (j >= end) goto <D.26322>; else goto <D.26321>;
        <D.26321>:
      }
      <D.30618>:
      D.30397 = cfg->native_code;
      D.30588 = tblock->native_offset;
      D.30589 = (sizetype) D.30588;
      D.30590 = D.30397 + D.30589;
      ei->try_end = D.30590;
      D.30588 = tblock->native_offset;
      D.30599 = D.30588 == 0;
      D.30600 = (long int) D.30599;
      D.30601 = __builtin_expect (D.30600, 0);
      if (D.30601 != 0) goto <D.30627>; else goto <D.30628>;
      <D.30627>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.30628>:
      D.30334 = cfg->cil_offset_to_bb;
      D.30569 = ec->handler_offset;
      D.30629 = (long unsigned int) D.30569;
      D.30630 = D.30629 * 8;
      D.30631 = D.30334 + D.30630;
      tblock = *D.30631;
      D.30583 = tblock == 0B;
      D.30584 = (long int) D.30583;
      D.30585 = __builtin_expect (D.30584, 0);
      if (D.30585 != 0) goto <D.30632>; else goto <D.30633>;
      <D.30632>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.30633>:
      D.30397 = cfg->native_code;
      D.30588 = tblock->native_offset;
      D.30589 = (sizetype) D.30588;
      D.30590 = D.30397 + D.30589;
      ei->handler_start = D.30590;
      tmp = cfg->try_block_holes;
      goto <D.26328>;
      <D.26327>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.30397 = cfg->native_code;
        D.30634 = hole->basic_block;
        D.30635 = D.30634->native_offset;
        D.30634 = hole->basic_block;
        D.30636 = D.30634->native_length;
        D.30637 = D.30635 + D.30636;
        D.30638 = (sizetype) D.30637;
        hole_end = D.30397 + D.30638;
        D.30639 = hole->clause;
        if (D.30639 == ec) goto <D.30640>; else goto <D.30641>;
        <D.30640>:
        D.30642 = ei->try_end;
        if (D.30642 == hole_end) goto <D.30643>; else goto <D.30644>;
        <D.30643>:
        D.30355 = cfg->verbose_level;
        D.30356 = D.30355 > 3;
        D.30357 = (long int) D.30356;
        D.30358 = __builtin_expect (D.30357, 0);
        if (D.30358 != 0) goto <D.30645>; else goto <D.30646>;
        <D.30645>:
        D.30642 = ei->try_end;
        D.30647 = (long int) D.30642;
        D.30397 = cfg->native_code;
        D.30648 = (long int) D.30397;
        D.30649 = D.30647 - D.30648;
        D.30650 = (int) D.30649;
        D.30651 = hole->start_offset;
        printf ("\tShortening try block %d from %x to %x\n", i, D.30650, D.30651);
        <D.30646>:
        D.30397 = cfg->native_code;
        D.30651 = hole->start_offset;
        D.30652 = (sizetype) D.30651;
        D.30653 = D.30397 + D.30652;
        ei->try_end = D.30653;
        goto <D.26326>;
        <D.30644>:
        <D.30641>:
      }
      tmp = tmp->next;
      <D.26328>:
      if (tmp != 0B) goto <D.26327>; else goto <D.26326>;
      <D.26326>:
      D.30568 = ec->flags;
      if (D.30568 == 2) goto <D.30654>; else goto <D.30655>;
      <D.30654>:
      {
        int end_offset;

        D.30569 = ec->handler_offset;
        D.30656 = ec->handler_len;
        D.30657 = D.30569 + D.30656;
        D.30658 = header->code_size;
        if (D.30657 < D.30658) goto <D.30659>; else goto <D.30660>;
        <D.30659>:
        D.30334 = cfg->cil_offset_to_bb;
        D.30569 = ec->handler_offset;
        D.30656 = ec->handler_len;
        D.30657 = D.30569 + D.30656;
        D.30661 = (long unsigned int) D.30657;
        D.30662 = D.30661 * 8;
        D.30663 = D.30334 + D.30662;
        tblock = *D.30663;
        D.30588 = tblock->native_offset;
        if (D.30588 != 0) goto <D.30664>; else goto <D.30665>;
        <D.30664>:
        end_offset = tblock->native_offset;
        goto <D.30666>;
        <D.30665>:
        {
          int j;
          int end;

          D.30569 = ec->handler_offset;
          D.30656 = ec->handler_len;
          D.30657 = D.30569 + D.30656;
          j = (int) D.30657;
          D.30569 = ec->handler_offset;
          end = (int) D.30569;
          goto <D.26335>;
          <D.26334>:
          {
            struct MonoBasicBlock * bb;

            D.30334 = cfg->cil_offset_to_bb;
            D.30667 = (long unsigned int) j;
            D.30668 = D.30667 * 8;
            D.30669 = D.30334 + D.30668;
            bb = *D.30669;
            if (bb != 0B) goto <D.30670>; else goto <D.30671>;
            <D.30670>:
            D.30672 = bb->native_offset;
            if (D.30672 != 0) goto <D.30673>; else goto <D.30674>;
            <D.30673>:
            tblock = bb;
            goto <D.26333>;
            <D.30674>:
            <D.30671>:
          }
          j = j + -1;
          <D.26335>:
          if (j >= end) goto <D.26334>; else goto <D.26333>;
          <D.26333>:
          D.30588 = tblock->native_offset;
          D.30675 = tblock->native_length;
          end_offset = D.30588 + D.30675;
        }
        <D.30666>:
        goto <D.30676>;
        <D.30660>:
        D.30677 = cfg->epilog_begin;
        end_offset = (int) D.30677;
        <D.30676>:
        D.30397 = cfg->native_code;
        D.30678 = (sizetype) end_offset;
        D.30679 = D.30397 + D.30678;
        ei->data.handler_end = D.30679;
      }
      <D.30655>:
    }
    i = i + 1;
    <D.26337>:
    D.30368 = header->num_clauses;
    D.30680 = (int) D.30368;
    if (D.30680 > i) goto <D.26336>; else goto <D.26338>;
    <D.26338>:
  }
  <D.30565>:
  <D.30561>:
  D.30355 = cfg->verbose_level;
  D.30356 = D.30355 > 3;
  D.30357 = (long int) D.30356;
  D.30358 = __builtin_expect (D.30357, 0);
  if (D.30358 != 0) goto <D.30681>; else goto <D.30682>;
  <D.30681>:
  {
    int i;

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

      ei = &jinfo->clauses[i];
      D.30683 = ei->try_start;
      D.30684 = (long int) D.30683;
      D.30397 = cfg->native_code;
      D.30648 = (long int) D.30397;
      D.30685 = D.30684 - D.30648;
      start = (int) D.30685;
      D.30686 = ei->try_end;
      D.30687 = (long int) D.30686;
      D.30397 = cfg->native_code;
      D.30648 = (long int) D.30397;
      D.30688 = D.30687 - D.30648;
      end = (int) D.30688;
      D.30689 = ei->handler_start;
      D.30690 = (long int) D.30689;
      D.30397 = cfg->native_code;
      D.30648 = (long int) D.30397;
      D.30691 = D.30690 - D.30648;
      handler = (int) D.30691;
      D.30692 = ei->data.handler_end;
      D.30693 = (long int) D.30692;
      D.30397 = cfg->native_code;
      D.30648 = (long int) D.30397;
      D.30694 = D.30693 - D.30648;
      handler_end = (int) D.30694;
      D.30695 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.30695, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.26346>:
    D.30696 = jinfo->num_clauses;
    D.30697 = (int) D.30696;
    if (D.30697 > i) goto <D.26345>; else goto <D.26347>;
    <D.26347>:
  }
  <D.30682>:
  D.30698 = cfg->encoded_unwind_ops;
  if (D.30698 != 0B) goto <D.30699>; else goto <D.30700>;
  <D.30699>:
  D.30698 = cfg->encoded_unwind_ops;
  D.30701 = cfg->encoded_unwind_ops_len;
  D.30702 = mono_cache_unwind_info (D.30698, D.30701);
  jinfo->used_regs = D.30702;
  D.30698 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.30698);
  goto <D.30703>;
  <D.30700>:
  D.30704 = cfg->unwind_ops;
  if (D.30704 != 0B) goto <D.30705>; else goto <D.30706>;
  <D.30705>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.30704 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.30704, &info_len);
        info_len.102 = info_len;
        D.30708 = mono_cache_unwind_info (unwind_info, info_len.102);
        jinfo->used_regs = D.30708;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.30706>:
  <D.30703>:
  D.30709 = jinfo;
  return D.30709;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.30711;
  unsigned int D.30714;
  long unsigned int D.30715;
  long unsigned int D.30716;
  long unsigned int D.30717;
  int D.30718;
  void * * D.30719;
  long unsigned int D.30720;
  long unsigned int D.30721;
  void * * D.30722;
  long int D.30723;
  int D.30724;
  long int D.30725;
  int D.30726;
  unsigned char D.30727;
  int D.30728;
  int D.30729;
  int D.30732;
  int D.30733;
  unsigned int i.103;
  long unsigned int D.30735;
  struct GSList * D.30736;
  long int D.30739;
  long int D.30741;
  int D.30746;
  long unsigned int D.30747;
  long unsigned int D.30748;
  struct GSList * * D.30749;
  struct GSList * D.30750;
  int D.30751;
  long unsigned int D.30752;
  void * D.30753;
  struct GSList * D.30754;
  struct MonoInst * D.30756;
  short unsigned int D.30759;
  struct GSList * D.30766;
  long int D.30769;
  int D.30776;
  long unsigned int D.30777;
  long unsigned int D.30778;
  struct GSList * * D.30779;
  struct GSList * D.30780;
  int D.30781;
  long unsigned int D.30782;
  void * D.30783;
  struct GSList * D.30784;
  unsigned int D.30785;
  struct GSList * * D.30788;
  struct GSList * D.30789;
  unsigned int D.30790;
  int D.30791;
  int D.30792;
  long unsigned int D.30793;
  long unsigned int D.30794;
  void * D.30795;
  int D.30800;
  void * D.30801;
  long int D.30802;
  int D.30803;
  int * D.30804;
  int j.104;
  long unsigned int D.30806;
  long unsigned int D.30807;
  int * D.30808;
  long unsigned int D.30809;
  long unsigned int D.30810;
  union mono_mutex_t * D.30813;
  _Bool D.30816;
  long int D.30817;
  long int D.30818;
  void * D.30821;
  struct GHashTable * D.30822;
  struct MonoMethod * D.30823;
  void * D.30824;
  _Bool D.30829;
  long int D.30830;
  long int D.30831;
  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.30711 = cfg->seq_points;
  if (D.30711 == 0B) goto <D.30712>; else goto <D.30713>;
  <D.30712>:
  return;
  <D.30713>:
  D.30711 = cfg->seq_points;
  D.30714 = D.30711->len;
  D.30715 = (long unsigned int) D.30714;
  D.30716 = D.30715 * 32;
  D.30717 = D.30716 + 8;
  info = monoeg_malloc0 (D.30717);
  D.30711 = cfg->seq_points;
  D.30714 = D.30711->len;
  D.30718 = (int) D.30714;
  info->len = D.30718;
  i = 0;
  goto <D.26195>;
  <D.26194>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.30711 = cfg->seq_points;
    D.30719 = D.30711->pdata;
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30722 = D.30719 + D.30721;
    ins = *D.30722;
    D.30723 = ins->data.op[1].const_val;
    D.30724 = (int) D.30723;
    sp->il_offset = D.30724;
    D.30725 = ins->data.op[0].const_val;
    D.30726 = (int) D.30725;
    sp->native_offset = D.30726;
    D.30727 = ins->flags;
    D.30728 = (int) D.30727;
    D.30729 = D.30728 & 4;
    if (D.30729 != 0) goto <D.30730>; else goto <D.30731>;
    <D.30730>:
    D.30732 = sp->flags;
    D.30733 = D.30732 | 1;
    sp->flags = D.30733;
    <D.30731>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.26195>:
  i.103 = (unsigned int) i;
  D.30711 = cfg->seq_points;
  D.30714 = D.30711->len;
  if (i.103 < D.30714) goto <D.26194>; else goto <D.26196>;
  <D.26196>:
  D.30711 = cfg->seq_points;
  D.30714 = D.30711->len;
  D.30715 = (long unsigned int) D.30714;
  D.30735 = D.30715 * 8;
  next = monoeg_malloc0 (D.30735);
  bb = cfg->bb_entry;
  goto <D.26210>;
  <D.26209>:
  D.30736 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.30736);
  last = 0B;
  l = bb_seq_points;
  goto <D.26200>;
  <D.26199>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.30739 = ins->data.op[1].const_val;
    if (D.30739 == -1) goto <D.30737>; else goto <D.30740>;
    <D.30740>:
    D.30739 = ins->data.op[1].const_val;
    if (D.30739 == 16777215) goto <D.30737>; else goto <D.30738>;
    <D.30737>:
    // predicted unlikely by continue predictor.
    goto <D.26198>;
    <D.30738>:
    D.30741 = ins->data.op[0].const_val;
    if (D.30741 == -1) goto <D.30742>; else goto <D.30743>;
    <D.30742>:
    // predicted unlikely by continue predictor.
    goto <D.26198>;
    <D.30743>:
    if (last != 0B) goto <D.30744>; else goto <D.30745>;
    <D.30744>:
    D.30746 = last->backend.size;
    D.30747 = (long unsigned int) D.30746;
    D.30748 = D.30747 * 8;
    D.30749 = next + D.30748;
    D.30746 = last->backend.size;
    D.30747 = (long unsigned int) D.30746;
    D.30748 = D.30747 * 8;
    D.30749 = next + D.30748;
    D.30750 = *D.30749;
    D.30751 = ins->backend.size;
    D.30752 = (long unsigned int) D.30751;
    D.30753 = (void *) D.30752;
    D.30754 = monoeg_g_slist_append (D.30750, D.30753);
    *D.30749 = D.30754;
    goto <D.30755>;
    <D.30745>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.30755>:
    last = ins;
  }
  <D.26198>:
  l = l->next;
  <D.26200>:
  if (l != 0B) goto <D.26199>; else goto <D.26201>;
  <D.26201>:
  D.30756 = bb->last_ins;
  if (D.30756 != 0B) goto <D.30757>; else goto <D.30758>;
  <D.30757>:
  D.30756 = bb->last_ins;
  D.30759 = D.30756->opcode;
  if (D.30759 == 738) goto <D.30760>; else goto <D.30761>;
  <D.30760>:
  D.30736 = bb->seq_points;
  if (D.30736 != 0B) goto <D.30762>; else goto <D.30763>;
  <D.30762>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.30736 = bb->seq_points;
    l = monoeg_g_slist_last (D.30736);
    if (l != 0B) goto <D.30764>; else goto <D.30765>;
    <D.30764>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.26207>;
    <D.26206>:
    {
      struct GSList * l;

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

        ins = l->data;
        D.30769 = ins->data.op[1].const_val;
        if (D.30769 != -1) goto <D.30770>; else goto <D.30771>;
        <D.30770>:
        D.30769 = ins->data.op[1].const_val;
        if (D.30769 != 16777215) goto <D.30772>; else goto <D.30773>;
        <D.30772>:
        if (ins != endfinally_seq_point) goto <D.30774>; else goto <D.30775>;
        <D.30774>:
        D.30776 = endfinally_seq_point->backend.size;
        D.30777 = (long unsigned int) D.30776;
        D.30778 = D.30777 * 8;
        D.30779 = next + D.30778;
        D.30776 = endfinally_seq_point->backend.size;
        D.30777 = (long unsigned int) D.30776;
        D.30778 = D.30777 * 8;
        D.30779 = next + D.30778;
        D.30780 = *D.30779;
        D.30781 = ins->backend.size;
        D.30782 = (long unsigned int) D.30781;
        D.30783 = (void *) D.30782;
        D.30784 = monoeg_g_slist_append (D.30780, D.30783);
        *D.30779 = D.30784;
        <D.30775>:
        <D.30773>:
        <D.30771>:
      }
      <D.30768>:
    }
    bb2 = bb2->next_bb;
    <D.26207>:
    if (bb2 != 0B) goto <D.26206>; else goto <D.26208>;
    <D.26208>:
    <D.30765>:
  }
  <D.30763>:
  <D.30761>:
  <D.30758>:
  bb = bb->next_bb;
  <D.26210>:
  if (bb != 0B) goto <D.26209>; else goto <D.26211>;
  <D.26211>:
  D.30785 = cfg->verbose_level;
  if (D.30785 > 2) goto <D.30786>; else goto <D.30787>;
  <D.30786>:
  printf ("\nSEQ POINT MAP: \n");
  <D.30787>:
  i = 0;
  goto <D.26223>;
  <D.26222>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30788 = next + D.30721;
    D.30789 = *D.30788;
    D.30790 = monoeg_g_slist_length (D.30789);
    D.30791 = (int) D.30790;
    sp->next_len = D.30791;
    D.30792 = sp->next_len;
    D.30793 = (long unsigned int) D.30792;
    D.30794 = D.30793 * 4;
    D.30795 = monoeg_malloc (D.30794);
    sp->next = D.30795;
    j = 0;
    D.30785 = cfg->verbose_level;
    if (D.30785 > 2) goto <D.30796>; else goto <D.30797>;
    <D.30796>:
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30788 = next + D.30721;
    D.30789 = *D.30788;
    if (D.30789 != 0B) goto <D.30798>; else goto <D.30799>;
    <D.30798>:
    D.30800 = sp->il_offset;
    printf ("\tIL0x%x ->", D.30800);
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30788 = next + D.30721;
    l = *D.30788;
    goto <D.26217>;
    <D.26216>:
    D.30801 = l->data;
    D.30802 = (long int) D.30801;
    next_index = (int) D.30802;
    D.30803 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.30803);
    l = l->next;
    <D.26217>:
    if (l != 0B) goto <D.26216>; else goto <D.26218>;
    <D.26218>:
    printf ("\n");
    <D.30799>:
    <D.30797>:
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30788 = next + D.30721;
    l = *D.30788;
    goto <D.26220>;
    <D.26219>:
    D.30801 = l->data;
    D.30802 = (long int) D.30801;
    next_index = (int) D.30802;
    D.30804 = sp->next;
    j.104 = j;
    j = j.104 + 1;
    D.30806 = (long unsigned int) j.104;
    D.30807 = D.30806 * 4;
    D.30808 = D.30804 + D.30807;
    *D.30808 = next_index;
    l = l->next;
    <D.26220>:
    if (l != 0B) goto <D.26219>; else goto <D.26221>;
    <D.26221>:
    D.30720 = (long unsigned int) i;
    D.30721 = D.30720 * 8;
    D.30788 = next + D.30721;
    D.30789 = *D.30788;
    monoeg_g_slist_free (D.30789);
  }
  i = i + 1;
  <D.26223>:
  i.103 = (unsigned int) i;
  D.30711 = cfg->seq_points;
  D.30714 = D.30711->len;
  if (i.103 < D.30714) goto <D.26222>; else goto <D.26224>;
  <D.26224>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.30809 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.30810 = D.30809 & 274877906944;
  if (D.30810 == 0) goto <D.30811>; else goto <D.30812>;
  <D.30811>:
  {
    int ret;

    D.30813 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30813);
    if (ret != 0) goto <D.30814>; else goto <D.30815>;
    <D.30814>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30815>:
    D.30816 = ret != 0;
    D.30817 = (long int) D.30816;
    D.30818 = __builtin_expect (D.30817, 0);
    if (D.30818 != 0) goto <D.30819>; else goto <D.30820>;
    <D.30819>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.30820>:
  }
  D.30821 = domain->runtime_info;
  D.30822 = MEM[(struct MonoJitDomainInfo *)D.30821].seq_points;
  D.30823 = cfg->method_to_register;
  D.30824 = monoeg_g_hash_table_lookup (D.30822, D.30823);
  if (D.30824 == 0B) goto <D.30825>; else goto <D.30826>;
  <D.30825>:
  D.30821 = domain->runtime_info;
  D.30822 = MEM[(struct MonoJitDomainInfo *)D.30821].seq_points;
  D.30823 = cfg->method_to_register;
  monoeg_g_hash_table_insert_replace (D.30822, D.30823, info, 0);
  <D.30826>:
  {
    int ret;

    D.30813 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30813);
    if (ret != 0) goto <D.30827>; else goto <D.30828>;
    <D.30827>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30828>:
    D.30829 = ret != 0;
    D.30830 = (long int) D.30829;
    D.30831 = __builtin_expect (D.30830, 0);
    if (D.30831 != 0) goto <D.30832>; else goto <D.30833>;
    <D.30832>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.30833>:
  }
  <D.30812>:
  D.30711 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.30711, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.30835;
  long unsigned int D.30836;
  long unsigned int D.30837;
  struct MonoBasicBlock * * D.30838;
  struct MonoInst * D.30839;
  long unsigned int D.30842;
  long unsigned int D.30843;
  struct GSList * * D.30844;
  void * D.30845;
  long int D.30846;
  unsigned int D.30847;
  unsigned int dst_index.105;
  struct GSList * D.30852;
  long unsigned int D.30853;
  void * D.30854;
  struct GSList * D.30855;
  int D.30859;
  short int D.30860;
  int D.30861;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.26179>;
  <D.26178>:
  D.30835 = bb->in_bb;
  D.30836 = (long unsigned int) i;
  D.30837 = D.30836 * 8;
  D.30838 = D.30835 + D.30837;
  in_bb = *D.30838;
  D.30839 = in_bb->last_seq_point;
  if (D.30839 != 0B) goto <D.30840>; else goto <D.30841>;
  <D.30840>:
  {
    int src_index;
    int dst_index;

    D.30839 = in_bb->last_seq_point;
    src_index = D.30839->backend.size;
    dst_index = ins->backend.size;
    D.30842 = (long unsigned int) src_index;
    D.30843 = D.30842 * 8;
    D.30844 = next + D.30843;
    l = *D.30844;
    goto <D.26177>;
    <D.26176>:
    D.30845 = l->data;
    D.30846 = (long int) D.30845;
    D.30847 = (unsigned int) D.30846;
    dst_index.105 = (unsigned int) dst_index;
    if (D.30847 == dst_index.105) goto <D.26175>; else goto <D.30849>;
    <D.30849>:
    l = l->next;
    <D.26177>:
    if (l != 0B) goto <D.26176>; else goto <D.26175>;
    <D.26175>:
    if (l == 0B) goto <D.30850>; else goto <D.30851>;
    <D.30850>:
    D.30842 = (long unsigned int) src_index;
    D.30843 = D.30842 * 8;
    D.30844 = next + D.30843;
    D.30842 = (long unsigned int) src_index;
    D.30843 = D.30842 * 8;
    D.30844 = next + D.30843;
    D.30852 = *D.30844;
    D.30853 = (long unsigned int) dst_index;
    D.30854 = (void *) D.30853;
    D.30855 = monoeg_g_slist_append (D.30852, D.30854);
    *D.30844 = D.30855;
    <D.30851>:
  }
  goto <D.30856>;
  <D.30841>:
  if (depth <= 4) goto <D.30857>; else goto <D.30858>;
  <D.30857>:
  D.30859 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.30859);
  <D.30858>:
  <D.30856>:
  i = i + 1;
  <D.26179>:
  D.30860 = bb->in_count;
  D.30861 = (int) D.30860;
  if (D.30861 > i) goto <D.26178>; else goto <D.26180>;
  <D.26180>:
}


mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.30862;
  struct MonoMethod * D.30863;
  long unsigned int D.30866;
  long unsigned int D.30867;
  int inited.106;
  int lookups.107;
  int lookups.108;
  int failed_lookups.109;
  int failed_lookups.110;
  struct MonoJitInfo * D.30879;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.30862 = &domain->jit_code_hash;
  D.30863 = mini_get_shared_method (method);
  ji = mono_internal_hash_table_lookup (D.30862, D.30863);
  if (ji != 0B) goto <D.30864>; else goto <D.30865>;
  <D.30864>:
  D.30866 = BIT_FIELD_REF <*ji, 64, 256>;
  D.30867 = D.30866 & 131072;
  if (D.30867 == 0) goto <D.30868>; else goto <D.30869>;
  <D.30868>:
  ji = 0B;
  <D.30869>:
  <D.30865>:
  inited.106 = inited;
  if (inited.106 == 0) goto <D.30871>; else goto <D.30872>;
  <D.30871>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.30872>:
  lookups.107 = lookups;
  lookups.108 = lookups.107 + 1;
  lookups = lookups.108;
  if (ji == 0B) goto <D.30875>; else goto <D.30876>;
  <D.30875>:
  failed_lookups.109 = failed_lookups;
  failed_lookups.110 = failed_lookups.109 + 1;
  failed_lookups = failed_lookups.110;
  <D.30876>:
  D.30879 = ji;
  return D.30879;
}


mono_enable_jit_map ()
{
  struct FILE * perf_map_file.111;
  int D.30884;
  struct FILE * perf_map_file.112;

  perf_map_file.111 = perf_map_file;
  if (perf_map_file.111 == 0B) goto <D.30882>; else goto <D.30883>;
  <D.30882>:
  {
    char name[64];

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


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

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


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

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


mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.115;
  struct MonoMethod * D.30895;
  void * D.30896;
  int D.30897;

  perf_map_file.115 = perf_map_file;
  if (perf_map_file.115 != 0B) goto <D.30893>; else goto <D.30894>;
  <D.30893>:
  {
    char * name;

    D.30895 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.30895, 1);
    D.30896 = jinfo->code_start;
    D.30897 = jinfo->code_size;
    mono_emit_jit_tramp (D.30896, D.30897, name);
    monoeg_g_free (name);
  }
  <D.30894>:
}


mono_jit_map_is_enabled ()
{
  gboolean D.30898;
  struct FILE * perf_map_file.116;
  _Bool D.30900;

  perf_map_file.116 = perf_map_file;
  D.30900 = perf_map_file.116 != 0B;
  D.30898 = (gboolean) D.30900;
  return D.30898;
}


mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.117;
  unsigned int D.30903;
  struct MonoException * ex.118;
  _Bool D.30907;
  long int D.30908;
  long int D.30909;
  void * D.30912;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.117 = default_opt;
      D.30903 = mono_get_optimizations_for_method (method, default_opt.117);
      code = mono_jit_compile_method_with_opt (method, D.30903, &ex);
      if (code == 0B) goto <D.30904>; else goto <D.30905>;
      <D.30904>:
      ex.118 = ex;
      D.30907 = ex.118 == 0B;
      D.30908 = (long int) D.30907;
      D.30909 = __builtin_expect (D.30908, 0);
      if (D.30909 != 0) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.30911>:
      ex.118 = ex;
      mono_raise_exception (ex.118);
      <D.30905>:
      D.30912 = code;
      return D.30912;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  long unsigned int D.30915;
  long unsigned int D.30916;
  <unnamed type> D.30921;
  void * D.30924;
  _Bool D.30925;
  long int D.30926;
  long int D.30927;
  long unsigned int D.30930;
  struct MonoClass * D.30935;
  struct MonoImage * D.30936;
  struct MonoImage * D.30937;
  long unsigned int D.30939;
  unsigned int D.30940;
  _Bool D.30946;
  long int D.30947;
  long int D.30948;
  <unnamed type> D.30951;
  long unsigned int D.30963;
  long unsigned int D.30964;
  int D.30965;
  int D.30966;
  _Bool D.30967;
  long int D.30968;
  long int D.30969;
  _Bool D.30972;
  int D.30973;
  void * D.30976;
  void * D.30977;
  int opt.119;
  struct MonoDomain * D.30984;
  _Bool D.30985;
  long int D.30986;
  long int D.30987;
  _Bool D.30994;
  long int D.30995;
  long int D.30996;
  const void * D.30999;
  _Bool D.31004;
  long int D.31005;
  long int D.31006;
  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.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30916 = D.30915 & 124;
  if (D.30916 == 24) goto <D.30917>; else goto <D.30918>;
  <D.30917>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.30918>:
  if (winfo != 0B) goto <D.30919>; else goto <D.30920>;
  <D.30919>:
  D.30921 = winfo->subtype;
  if (D.30921 == 15) goto <D.30922>; else goto <D.30923>;
  <D.30922>:
  D.30924 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.30924);
  D.30925 = callinfo == 0B;
  D.30926 = (long int) D.30925;
  D.30927 = __builtin_expect (D.30926, 0);
  if (D.30927 != 0) goto <D.30928>; else goto <D.30929>;
  <D.30928>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.30929>:
  opt = opt | 512;
  <D.30923>:
  <D.30920>:
  D.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30930 = D.30915 & 512;
  if (D.30930 != 0) goto <D.30931>; else goto <D.30932>;
  <D.30931>:
  opt = opt & 4294966783;
  <D.30932>:
  D.30935 = method->klass;
  D.30936 = D.30935->image;
  D.30937 = mono_get_corlib ();
  if (D.30936 != D.30937) goto <D.30933>; else goto <D.30938>;
  <D.30938>:
  D.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30939 = D.30915 & 4096;
  if (D.30939 != 0) goto <D.30933>; else goto <D.30934>;
  <D.30933>:
  opt = opt & 4294966783;
  <D.30934>:
  D.30940 = opt & 512;
  if (D.30940 != 0) goto <D.30941>; else goto <D.30942>;
  <D.30941>:
  target_domain = mono_get_root_domain ();
  goto <D.30943>;
  <D.30942>:
  target_domain = domain;
  <D.30943>:
  D.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30916 = D.30915 & 124;
  if (D.30916 == 100) goto <D.30944>; else goto <D.30945>;
  <D.30944>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.30946 = info == 0B;
    D.30947 = (long int) D.30946;
    D.30948 = __builtin_expect (D.30947, 0);
    if (D.30948 != 0) goto <D.30949>; else goto <D.30950>;
    <D.30949>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.30950>:
    D.30951 = info->subtype;
    if (D.30951 == 17) goto <D.30952>; else goto <D.30953>;
    <D.30952>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.30915 = BIT_FIELD_REF <*method, 64, 256>;
      D.30939 = D.30915 & 4096;
      if (D.30939 != 0) goto <D.30954>; else goto <D.30955>;
      <D.30954>:
      ctx = mono_method_get_context (method);
      <D.30955>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.30956>; else goto <D.30957>;
      <D.30956>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.30957>:
    }
    <D.30953>:
  }
  <D.30945>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.30958>; else goto <D.30959>;
  <D.30958>:
  if (domain == target_domain) goto <D.30960>; else goto <D.30962>;
  <D.30962>:
  D.30963 = BIT_FIELD_REF <*info, 64, 256>;
  D.30964 = D.30963 & 32768;
  if (D.30964 != 0) goto <D.30960>; else goto <D.30961>;
  <D.30960>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.30965 = mono_jit_stats.methods_lookups;
    D.30966 = D.30965 + 1;
    mono_jit_stats.methods_lookups = D.30966;
    D.30935 = method->klass;
    vtable = mono_class_vtable (domain, D.30935);
    D.30967 = vtable == 0B;
    D.30968 = (long int) D.30967;
    D.30969 = __builtin_expect (D.30968, 0);
    if (D.30969 != 0) goto <D.30970>; else goto <D.30971>;
    <D.30970>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.30971>:
    D.30972 = ex == 0B;
    D.30973 = (int) D.30972;
    tmpEx = mono_runtime_class_init_full (vtable, D.30973);
    if (tmpEx != 0B) goto <D.30974>; else goto <D.30975>;
    <D.30974>:
    *ex = tmpEx;
    D.30976 = 0B;
    return D.30976;
    <D.30975>:
    D.30977 = info->code_start;
    D.30976 = mono_create_ftnptr (target_domain, D.30977);
    return D.30976;
  }
  <D.30961>:
  <D.30959>:
  opt.119 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.119, ex);
  if (code == 0B) goto <D.30979>; else goto <D.30980>;
  <D.30979>:
  D.30976 = 0B;
  return D.30976;
  <D.30980>:
  D.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30916 = D.30915 & 124;
  if (D.30916 == 96) goto <D.30981>; else goto <D.30983>;
  <D.30983>:
  D.30915 = BIT_FIELD_REF <*method, 64, 256>;
  D.30916 = D.30915 & 124;
  if (D.30916 == 112) goto <D.30981>; else goto <D.30982>;
  <D.30981>:
  {
    struct MonoDomain * d;

    try
      {
        D.30984 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.30984, code, &d);
        D.30985 = ji == 0B;
        D.30986 = (long int) D.30985;
        D.30987 = __builtin_expect (D.30986, 0);
        if (D.30987 != 0) goto <D.30988>; else goto <D.30989>;
        <D.30988>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.30989>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.30982>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.30990>; else goto <D.30991>;
  <D.30990>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30992>; else goto <D.30993>;
    <D.30992>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30993>:
    D.30994 = ret != 0;
    D.30995 = (long int) D.30994;
    D.30996 = __builtin_expect (D.30995, 0);
    if (D.30996 != 0) goto <D.30997>; else goto <D.30998>;
    <D.30997>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6230, "ret == 0");
    <D.30998>:
  }
  D.30999 = callinfo->wrapper;
  if (D.30999 == 0B) goto <D.31000>; else goto <D.31001>;
  <D.31000>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.31001>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31002>; else goto <D.31003>;
    <D.31002>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31003>:
    D.31004 = ret != 0;
    D.31005 = (long int) D.31004;
    D.31006 = __builtin_expect (D.31005, 0);
    if (D.31006 != 0) goto <D.31007>; else goto <D.31008>;
    <D.31007>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.31008>:
  }
  mono_loader_unlock ();
  <D.30991>:
  D.30976 = p;
  return D.30976;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.31010;
  _Bool D.31013;
  long int D.31014;
  long int D.31015;
  _Bool D.31020;
  long int D.31021;
  long int D.31022;
  struct MonoJitInfo * D.31025;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.31010 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.31010);
    if (ret != 0) goto <D.31011>; else goto <D.31012>;
    <D.31011>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31012>:
    D.31013 = ret != 0;
    D.31014 = (long int) D.31013;
    D.31015 = __builtin_expect (D.31014, 0);
    if (D.31015 != 0) goto <D.31016>; else goto <D.31017>;
    <D.31016>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.31017>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.31010 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31010);
    if (ret != 0) goto <D.31018>; else goto <D.31019>;
    <D.31018>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31019>:
    D.31020 = ret != 0;
    D.31021 = (long int) D.31020;
    D.31022 = __builtin_expect (D.31021, 0);
    if (D.31022 != 0) goto <D.31023>; else goto <D.31024>;
    <D.31023>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.31024>:
  }
  mono_loader_unlock ();
  D.31025 = info;
  return D.31025;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.31027;
  struct MonoJitInfo * D.31030;
  int D.31031;
  struct MonoJitInfo * ji;

  D.31027 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.31027, method);
  if (ji != 0B) goto <D.31028>; else goto <D.31029>;
  <D.31028>:
  D.31030 = ji;
  return D.31030;
  <D.31029>:
  D.31031 = mono_method_is_generic_sharable (method, 0);
  if (D.31031 == 0) goto <D.31032>; else goto <D.31033>;
  <D.31032>:
  D.31030 = 0B;
  return D.31030;
  <D.31033>:
  D.31030 = mono_domain_lookup_shared_generic (domain, method);
  return D.31030;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.31035;
  struct MonoMethod * method.120;
  struct MonoClass * D.31039;
  _Bool D.31042;
  long int D.31043;
  long int D.31044;
  void * D.31047;
  short unsigned int D.31050;
  int D.31051;
  int D.31052;
  short unsigned int D.31054;
  int D.31055;
  int D.31056;
  void * D.31057;
  void * D.31062;
  int D.31064;
  char * D.31067;
  struct MonoImage * D.31068;
  char * D.31069;
  int check_for_pending_exc.121;
  void * D.31072;
  struct MonoDomain * D.31075;
  int D.31078;
  struct MonoClass * D.31081;
  struct MonoClass * D.31082;
  char D.31086;
  int D.26582;
  int iftmp.122;
  int D.26581;
  const char[6] * D.31091;
  unsigned char D.31092;
  int D.31093;
  unsigned char D.31094;
  int D.31095;
  const unsigned char * D.31100;
  unsigned char D.31101;
  int D.31102;
  const unsigned char * D.31103;
  unsigned char D.31104;
  int D.31105;
  const unsigned char * D.31110;
  unsigned char D.31111;
  int D.31112;
  const unsigned char * D.31113;
  unsigned char D.31114;
  int D.31115;
  const unsigned char * D.31120;
  unsigned char D.31121;
  int D.31122;
  const unsigned char * D.31123;
  unsigned char D.31124;
  int D.31125;
  _Bool D.31128;
  long int D.31129;
  long int D.31130;
  const void * D.31133;
  int D.26592;
  int iftmp.123;
  int D.26591;
  const char[7] * D.31139;
  unsigned char D.31140;
  int D.31141;
  unsigned char D.31142;
  int D.31143;
  const unsigned char * D.31148;
  unsigned char D.31149;
  int D.31150;
  const unsigned char * D.31151;
  unsigned char D.31152;
  int D.31153;
  const unsigned char * D.31158;
  unsigned char D.31159;
  int D.31160;
  const unsigned char * D.31161;
  unsigned char D.31162;
  int D.31163;
  const unsigned char * D.31168;
  unsigned char D.31169;
  int D.31170;
  const unsigned char * D.31171;
  unsigned char D.31172;
  int D.31173;
  int D.26601;
  int iftmp.124;
  int D.26600;
  const char[12] * D.31181;
  unsigned char D.31182;
  int D.31183;
  unsigned char D.31184;
  int D.31185;
  const unsigned char * D.31190;
  unsigned char D.31191;
  int D.31192;
  const unsigned char * D.31193;
  unsigned char D.31194;
  int D.31195;
  const unsigned char * D.31200;
  unsigned char D.31201;
  int D.31202;
  const unsigned char * D.31203;
  unsigned char D.31204;
  int D.31205;
  const unsigned char * D.31210;
  unsigned char D.31211;
  int D.31212;
  const unsigned char * D.31213;
  unsigned char D.31214;
  int D.31215;
  void * D.31218;
  int D.26610;
  int iftmp.125;
  int D.26609;
  const char[10] * D.31224;
  unsigned char D.31225;
  int D.31226;
  unsigned char D.31227;
  int D.31228;
  const unsigned char * D.31233;
  unsigned char D.31234;
  int D.31235;
  const unsigned char * D.31236;
  unsigned char D.31237;
  int D.31238;
  const unsigned char * D.31243;
  unsigned char D.31244;
  int D.31245;
  const unsigned char * D.31246;
  unsigned char D.31247;
  int D.31248;
  const unsigned char * D.31253;
  unsigned char D.31254;
  int D.31255;
  const unsigned char * D.31256;
  unsigned char D.31257;
  int D.31258;
  void * D.31262;
  struct MonoImage * D.31263;
  struct MonoException * D.31264;
  long unsigned int D.31265;
  long unsigned int D.31266;
  <unnamed type> D.31269;
  unsigned int D.31270;
  _Bool D.31273;
  struct MonoTrampInfo * in_tinfo.126;
  struct MonoTrampInfo * out_tinfo.127;
  int mono_aot_only.128;
  const char * iftmp.129;
  struct MonoTrampInfo * tinfo.130;
  struct MonoDomain * D.31292;
  struct MonoException * D.31298;
  unsigned int opt.131;
  double D.31300;
  double D.31301;
  double D.31302;
  unsigned int D.31303;
  void * D.31307;
  char * D.31313;
  guint32 * D.31327;
  struct MonoMethod * D.31328;
  void * * D.31329;
  struct MonoDomain * D.31330;
  unsigned int D.31333;
  unsigned int D.31334;
  union mono_mutex_t * D.31337;
  _Bool D.31340;
  long int D.31341;
  long int D.31342;
  union mono_mutex_t * D.31345;
  _Bool D.31348;
  long int D.31349;
  long int D.31350;
  struct MonoDomain * D.31357;
  long unsigned int D.31359;
  long unsigned int D.31360;
  struct MonoInternalHashTable * D.31363;
  struct MonoJitInfo * D.31364;
  struct MonoMethod * D.31365;
  _Bool D.31368;
  long int D.31369;
  long int D.31370;
  struct MonoGenericSharingContext * D.31373;
  int D.31376;
  long unsigned int D.31379;
  long unsigned int D.31380;
  int D.31381;
  long unsigned int D.31384;
  long unsigned int D.31385;
  _Bool D.31389;
  long int D.31390;
  long int D.31391;
  int D.31394;
  int D.31395;
  int D.31396;
  int D.31397;
  int D.31398;
  int D.31399;
  int D.31400;
  int D.31401;
  int D.31402;
  int D.31403;
  int D.31404;
  int D.31405;
  int D.31406;
  int D.31407;
  int D.31408;
  int D.31409;
  int D.31410;
  int D.31411;
  int D.31412;
  int D.31413;
  int D.31414;
  int D.31415;
  int D.31416;
  int D.31417;
  int D.31418;
  int D.31419;
  int D.31420;
  int D.31421;
  int D.31422;
  void * D.31423;
  struct GHashTable * D.31424;
  void * D.31429;
  _Bool D.31432;
  long int D.31433;
  long int D.31434;
  _Bool D.31439;
  long int D.31440;
  long int D.31441;
  unsigned int D.31444;
  struct MonoMethod * D.31449;
  struct MonoMethod * D.31452;
  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.31035 = opt & 65536;
  if (D.31035 != 0) goto <D.31036>; else goto <D.31037>;
  <D.31036>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.120 = method;
    D.31039 = method.120->klass;
    mono_class_init (D.31039);
    method.120 = method;
    code = mono_aot_get_method (domain, method.120);
    if (code != 0B) goto <D.31040>; else goto <D.31041>;
    <D.31040>:
    method.120 = method;
    D.31039 = method.120->klass;
    vtable = mono_class_vtable (domain, D.31039);
    D.31042 = vtable == 0B;
    D.31043 = (long int) D.31042;
    D.31044 = __builtin_expect (D.31043, 0);
    if (D.31044 != 0) goto <D.31045>; else goto <D.31046>;
    <D.31045>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.31046>:
    mono_runtime_class_init (vtable);
    D.31047 = code;
    return D.31047;
    <D.31041>:
  }
  <D.31037>:
  method.120 = method;
  D.31050 = method.120->iflags;
  D.31051 = (int) D.31050;
  D.31052 = D.31051 & 4096;
  if (D.31052 != 0) goto <D.31048>; else goto <D.31053>;
  <D.31053>:
  method.120 = method;
  D.31054 = method.120->flags;
  D.31055 = (int) D.31054;
  D.31056 = D.31055 & 8192;
  if (D.31056 != 0) goto <D.31048>; else goto <D.31049>;
  <D.31048>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.31057 = piinfo->addr;
    if (D.31057 == 0B) goto <D.31058>; else goto <D.31059>;
    <D.31058>:
    method.120 = method;
    D.31050 = method.120->iflags;
    D.31051 = (int) D.31050;
    D.31052 = D.31051 & 4096;
    if (D.31052 != 0) goto <D.31060>; else goto <D.31061>;
    <D.31060>:
    method.120 = method;
    D.31062 = mono_lookup_internal_call (method.120);
    piinfo->addr = D.31062;
    goto <D.31063>;
    <D.31061>:
    method.120 = method;
    D.31050 = method.120->iflags;
    D.31051 = (int) D.31050;
    D.31064 = D.31051 & 1;
    if (D.31064 != 0) goto <D.31065>; else goto <D.31066>;
    <D.31065>:
    method.120 = method;
    D.31067 = mono_method_full_name (method.120, 1);
    method.120 = method;
    D.31039 = method.120->klass;
    D.31068 = D.31039->image;
    D.31069 = D.31068->name;
    monoeg_g_log (0B, 16, "Method \'%s\' in assembly \'%s\' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", D.31067, D.31069);
    goto <D.31070>;
    <D.31066>:
    method.120 = method;
    mono_lookup_pinvoke_call (method.120, 0B, 0B);
    <D.31070>:
    <D.31063>:
    <D.31059>:
    method.120 = method;
    check_for_pending_exc.121 = check_for_pending_exc;
    nm = mono_marshal_get_native_wrapper (method.120, check_for_pending_exc.121, 0);
    D.31072 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.31072);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.31073>; else goto <D.31074>;
    <D.31073>:
    D.31075 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.31075, code);
    <D.31074>:
    if (jinfo != 0B) goto <D.31076>; else goto <D.31077>;
    <D.31076>:
    method.120 = method;
    mono_profiler_method_end_jit (method.120, jinfo, 0);
    <D.31077>:
    D.31047 = code;
    return D.31047;
  }
  <D.31049>:
  method.120 = method;
  D.31050 = method.120->iflags;
  D.31051 = (int) D.31050;
  D.31078 = D.31051 & 3;
  if (D.31078 != 0) goto <D.31079>; else goto <D.31080>;
  <D.31079>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.120 = method;
    name = method.120->name;
    method.120 = method;
    D.31039 = method.120->klass;
    D.31081 = D.31039->parent;
    D.31082 = mono_defaults.multicastdelegate_class;
    if (D.31081 == D.31082) goto <D.31083>; else goto <D.31084>;
    <D.31083>:
    D.31086 = *name;
    if (D.31086 == 46) goto <D.31087>; else goto <D.31085>;
    <D.31087>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.31091 = ".ctor";
        D.31092 = MEM[(const unsigned char *)D.31091];
        D.31093 = (int) D.31092;
        D.31094 = *__s2;
        D.31095 = (int) D.31094;
        __result = D.31093 - D.31095;
        {
          if (__s2_len != 0) goto <D.31096>; else goto <D.31097>;
          <D.31096>:
          if (__result == 0) goto <D.31098>; else goto <D.31099>;
          <D.31098>:
          D.31100 = &MEM[(void *)".ctor" + 1B];
          D.31101 = *D.31100;
          D.31102 = (int) D.31101;
          D.31103 = __s2 + 1;
          D.31104 = *D.31103;
          D.31105 = (int) D.31104;
          __result = D.31102 - D.31105;
          if (__s2_len > 1) goto <D.31106>; else goto <D.31107>;
          <D.31106>:
          if (__result == 0) goto <D.31108>; else goto <D.31109>;
          <D.31108>:
          D.31110 = &MEM[(void *)".ctor" + 2B];
          D.31111 = *D.31110;
          D.31112 = (int) D.31111;
          D.31113 = __s2 + 2;
          D.31114 = *D.31113;
          D.31115 = (int) D.31114;
          __result = D.31112 - D.31115;
          if (__s2_len > 2) goto <D.31116>; else goto <D.31117>;
          <D.31116>:
          if (__result == 0) goto <D.31118>; else goto <D.31119>;
          <D.31118>:
          D.31120 = &MEM[(void *)".ctor" + 3B];
          D.31121 = *D.31120;
          D.31122 = (int) D.31121;
          D.31123 = __s2 + 3;
          D.31124 = *D.31123;
          D.31125 = (int) D.31124;
          __result = D.31122 - D.31125;
          <D.31119>:
          <D.31117>:
          <D.31109>:
          <D.31107>:
          <D.31099>:
          <D.31097>:
        }
        D.26581 = __result;
      }
      iftmp.122 = -D.26581;
      goto <D.31126>;
      <D.31090>:
      iftmp.122 = __builtin_strcmp (name, ".ctor");
      <D.31126>:
      D.26582 = iftmp.122;
    }
    if (D.26582 == 0) goto <D.31127>; else goto <D.31085>;
    <D.31127>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.31128 = mi == 0B;
      D.31129 = (long int) D.31128;
      D.31130 = __builtin_expect (D.31129, 0);
      if (D.31130 != 0) goto <D.31131>; else goto <D.31132>;
      <D.31131>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.31132>:
      D.31133 = mono_icall_get_wrapper_full (mi, 1);
      D.31047 = mono_get_addr_from_ftnptr (D.31133);
      return D.31047;
    }
    <D.31085>:
    D.31086 = *name;
    if (D.31086 == 73) goto <D.31135>; else goto <D.31134>;
    <D.31135>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.31139 = "Invoke";
        D.31140 = MEM[(const unsigned char *)D.31139];
        D.31141 = (int) D.31140;
        D.31142 = *__s2;
        D.31143 = (int) D.31142;
        __result = D.31141 - D.31143;
        {
          if (__s2_len != 0) goto <D.31144>; else goto <D.31145>;
          <D.31144>:
          if (__result == 0) goto <D.31146>; else goto <D.31147>;
          <D.31146>:
          D.31148 = &MEM[(void *)"Invoke" + 1B];
          D.31149 = *D.31148;
          D.31150 = (int) D.31149;
          D.31151 = __s2 + 1;
          D.31152 = *D.31151;
          D.31153 = (int) D.31152;
          __result = D.31150 - D.31153;
          if (__s2_len > 1) goto <D.31154>; else goto <D.31155>;
          <D.31154>:
          if (__result == 0) goto <D.31156>; else goto <D.31157>;
          <D.31156>:
          D.31158 = &MEM[(void *)"Invoke" + 2B];
          D.31159 = *D.31158;
          D.31160 = (int) D.31159;
          D.31161 = __s2 + 2;
          D.31162 = *D.31161;
          D.31163 = (int) D.31162;
          __result = D.31160 - D.31163;
          if (__s2_len > 2) goto <D.31164>; else goto <D.31165>;
          <D.31164>:
          if (__result == 0) goto <D.31166>; else goto <D.31167>;
          <D.31166>:
          D.31168 = &MEM[(void *)"Invoke" + 3B];
          D.31169 = *D.31168;
          D.31170 = (int) D.31169;
          D.31171 = __s2 + 3;
          D.31172 = *D.31171;
          D.31173 = (int) D.31172;
          __result = D.31170 - D.31173;
          <D.31167>:
          <D.31165>:
          <D.31157>:
          <D.31155>:
          <D.31147>:
          <D.31145>:
        }
        D.26591 = __result;
      }
      iftmp.123 = -D.26591;
      goto <D.31174>;
      <D.31138>:
      iftmp.123 = __builtin_strcmp (name, "Invoke");
      <D.31174>:
      D.26592 = iftmp.123;
    }
    if (D.26592 == 0) goto <D.31175>; else goto <D.31134>;
    <D.31175>:
    method.120 = method;
    D.31039 = method.120->klass;
    D.31047 = mono_create_delegate_trampoline (target_domain, D.31039);
    return D.31047;
    <D.31134>:
    D.31086 = *name;
    if (D.31086 == 66) goto <D.31177>; else goto <D.31176>;
    <D.31177>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.31181 = "BeginInvoke";
        D.31182 = MEM[(const unsigned char *)D.31181];
        D.31183 = (int) D.31182;
        D.31184 = *__s2;
        D.31185 = (int) D.31184;
        __result = D.31183 - D.31185;
        {
          if (__s2_len != 0) goto <D.31186>; else goto <D.31187>;
          <D.31186>:
          if (__result == 0) goto <D.31188>; else goto <D.31189>;
          <D.31188>:
          D.31190 = &MEM[(void *)"BeginInvoke" + 1B];
          D.31191 = *D.31190;
          D.31192 = (int) D.31191;
          D.31193 = __s2 + 1;
          D.31194 = *D.31193;
          D.31195 = (int) D.31194;
          __result = D.31192 - D.31195;
          if (__s2_len > 1) goto <D.31196>; else goto <D.31197>;
          <D.31196>:
          if (__result == 0) goto <D.31198>; else goto <D.31199>;
          <D.31198>:
          D.31200 = &MEM[(void *)"BeginInvoke" + 2B];
          D.31201 = *D.31200;
          D.31202 = (int) D.31201;
          D.31203 = __s2 + 2;
          D.31204 = *D.31203;
          D.31205 = (int) D.31204;
          __result = D.31202 - D.31205;
          if (__s2_len > 2) goto <D.31206>; else goto <D.31207>;
          <D.31206>:
          if (__result == 0) goto <D.31208>; else goto <D.31209>;
          <D.31208>:
          D.31210 = &MEM[(void *)"BeginInvoke" + 3B];
          D.31211 = *D.31210;
          D.31212 = (int) D.31211;
          D.31213 = __s2 + 3;
          D.31214 = *D.31213;
          D.31215 = (int) D.31214;
          __result = D.31212 - D.31215;
          <D.31209>:
          <D.31207>:
          <D.31199>:
          <D.31197>:
          <D.31189>:
          <D.31187>:
        }
        D.26600 = __result;
      }
      iftmp.124 = -D.26600;
      goto <D.31216>;
      <D.31180>:
      iftmp.124 = __builtin_strcmp (name, "BeginInvoke");
      <D.31216>:
      D.26601 = iftmp.124;
    }
    if (D.26601 == 0) goto <D.31217>; else goto <D.31176>;
    <D.31217>:
    method.120 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.120);
    D.31218 = mono_compile_method (nm);
    D.31047 = mono_get_addr_from_ftnptr (D.31218);
    return D.31047;
    <D.31176>:
    D.31086 = *name;
    if (D.31086 == 69) goto <D.31219>; else goto <D.31220>;
    <D.31219>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.31224 = "EndInvoke";
        D.31225 = MEM[(const unsigned char *)D.31224];
        D.31226 = (int) D.31225;
        D.31227 = *__s2;
        D.31228 = (int) D.31227;
        __result = D.31226 - D.31228;
        {
          if (__s2_len != 0) goto <D.31229>; else goto <D.31230>;
          <D.31229>:
          if (__result == 0) goto <D.31231>; else goto <D.31232>;
          <D.31231>:
          D.31233 = &MEM[(void *)"EndInvoke" + 1B];
          D.31234 = *D.31233;
          D.31235 = (int) D.31234;
          D.31236 = __s2 + 1;
          D.31237 = *D.31236;
          D.31238 = (int) D.31237;
          __result = D.31235 - D.31238;
          if (__s2_len > 1) goto <D.31239>; else goto <D.31240>;
          <D.31239>:
          if (__result == 0) goto <D.31241>; else goto <D.31242>;
          <D.31241>:
          D.31243 = &MEM[(void *)"EndInvoke" + 2B];
          D.31244 = *D.31243;
          D.31245 = (int) D.31244;
          D.31246 = __s2 + 2;
          D.31247 = *D.31246;
          D.31248 = (int) D.31247;
          __result = D.31245 - D.31248;
          if (__s2_len > 2) goto <D.31249>; else goto <D.31250>;
          <D.31249>:
          if (__result == 0) goto <D.31251>; else goto <D.31252>;
          <D.31251>:
          D.31253 = &MEM[(void *)"EndInvoke" + 3B];
          D.31254 = *D.31253;
          D.31255 = (int) D.31254;
          D.31256 = __s2 + 3;
          D.31257 = *D.31256;
          D.31258 = (int) D.31257;
          __result = D.31255 - D.31258;
          <D.31252>:
          <D.31250>:
          <D.31242>:
          <D.31240>:
          <D.31232>:
          <D.31230>:
        }
        D.26609 = __result;
      }
      iftmp.125 = -D.26609;
      goto <D.31259>;
      <D.31223>:
      iftmp.125 = __builtin_strcmp (name, "EndInvoke");
      <D.31259>:
      D.26610 = iftmp.125;
    }
    if (D.26610 == 0) goto <D.31260>; else goto <D.31261>;
    <D.31260>:
    method.120 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.120);
    D.31262 = mono_compile_method (nm);
    D.31047 = mono_get_addr_from_ftnptr (D.31262);
    return D.31047;
    <D.31261>:
    <D.31220>:
    <D.31084>:
    method.120 = method;
    full_name = mono_method_full_name (method.120, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.31263 = mono_defaults.corlib;
    D.31264 = mono_exception_from_name_msg (D.31263, "System", "InvalidProgramException", msg);
    *jit_ex = D.31264;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.31047 = 0B;
    return D.31047;
  }
  <D.31080>:
  method.120 = method;
  D.31265 = BIT_FIELD_REF <*method.120, 64, 256>;
  D.31266 = D.31265 & 124;
  if (D.31266 == 100) goto <D.31267>; else goto <D.31268>;
  <D.31267>:
  {
    struct WrapperInfo * info;

    method.120 = method;
    info = mono_marshal_get_wrapper_info (method.120);
    D.31269 = info->subtype;
    D.31270 = D.31269 + 4294967278;
    if (D.31270 <= 1) goto <D.31271>; else goto <D.31272>;
    <D.31271>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.31269 = info->subtype;
          D.31273 = D.31269 == 18;
          is_in = (gboolean) D.31273;
          if (is_in != 0) goto <D.31275>; else goto <D.31274>;
          <D.31275>:
          in_tinfo.126 = in_tinfo;
          if (in_tinfo.126 != 0B) goto <D.31277>; else goto <D.31274>;
          <D.31277>:
          in_tinfo.126 = in_tinfo;
          D.31047 = in_tinfo.126->code;
          return D.31047;
          <D.31274>:
          if (is_in == 0) goto <D.31278>; else goto <D.31279>;
          <D.31278>:
          out_tinfo.127 = out_tinfo;
          if (out_tinfo.127 != 0B) goto <D.31281>; else goto <D.31282>;
          <D.31281>:
          out_tinfo.127 = out_tinfo;
          D.31047 = out_tinfo.127->code;
          return D.31047;
          <D.31282>:
          <D.31279>:
          mono_aot_only.128 = mono_aot_only;
          if (mono_aot_only.128 != 0) goto <D.31284>; else goto <D.31285>;
          <D.31284>:
          if (is_in != 0) goto <D.31287>; else goto <D.31288>;
          <D.31287>:
          iftmp.129 = "gsharedvt_trampoline";
          goto <D.31289>;
          <D.31288>:
          iftmp.129 = "gsharedvt_out_trampoline";
          <D.31289>:
          mono_aot_get_trampoline_full (iftmp.129, &tinfo);
          goto <D.31290>;
          <D.31285>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.31290>:
          method.120 = method;
          tinfo.130 = tinfo;
          jinfo = create_jit_info_for_trampoline (method.120, tinfo.130);
          D.31292 = mono_get_root_domain ();
          mono_jit_info_table_add (D.31292, jinfo);
          if (is_in != 0) goto <D.31293>; else goto <D.31294>;
          <D.31293>:
          tinfo.130 = tinfo;
          in_tinfo = tinfo.130;
          goto <D.31295>;
          <D.31294>:
          tinfo.130 = tinfo;
          out_tinfo = tinfo.130;
          <D.31295>:
          tinfo.130 = tinfo;
          D.31047 = tinfo.130->code;
          return D.31047;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.31272>:
  }
  <D.31268>:
  mono_aot_only.128 = mono_aot_only;
  if (mono_aot_only.128 != 0) goto <D.31296>; else goto <D.31297>;
  <D.31296>:
  {
    char * fullname;
    char * msg;

    method.120 = method;
    fullname = mono_method_full_name (method.120, 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.31298 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.31298;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.31047 = 0B;
    return D.31047;
  }
  <D.31297>:
  jit_timer = monoeg_g_timer_new ();
  method.120 = method;
  opt.131 = (unsigned int) opt;
  cfg = mini_method_compile (method.120, opt.131, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.31300 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.31301 = mono_jit_stats.jit_time;
  D.31302 = D.31301 + D.31300;
  mono_jit_stats.jit_time = D.31302;
  monoeg_g_timer_destroy (jit_timer);
  D.31303 = cfg->exception_type;
  switch (D.31303) <default: <D.26638>, case 0: <D.26619>, case 1: <D.26631>, case 3: <D.26627>, case 4: <D.26628>, case 5: <D.26623>, case 6: <D.26622>, case 7: <D.26621>, case 8: <D.26624>, case 9: <D.26629>, case 10: <D.26630>, case 12: <D.26625>, case 13: <D.26635>, case 14: <D.26637>>
  <D.26619>:
  goto <D.26620>;
  <D.26621>:
  <D.26622>:
  <D.26623>:
  <D.26624>:
  <D.26625>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.31304>; else goto <D.31305>;
    <D.31304>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.31306>;
    <D.31305>:
    D.31307 = cfg->exception_ptr;
    if (D.31307 != 0B) goto <D.31308>; else goto <D.31309>;
    <D.31308>:
    D.31307 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.31307);
    goto <D.31310>;
    <D.31309>:
    D.31303 = cfg->exception_type;
    if (D.31303 == 6) goto <D.31311>; else goto <D.31312>;
    <D.31311>:
    D.31263 = mono_defaults.corlib;
    D.31313 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.31263, "System", "MissingFieldException", D.31313);
    goto <D.31314>;
    <D.31312>:
    D.31303 = cfg->exception_type;
    if (D.31303 == 5) goto <D.31315>; else goto <D.31316>;
    <D.31315>:
    D.31263 = mono_defaults.corlib;
    D.31313 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.31263, "System", "MissingMethodException", D.31313);
    goto <D.31317>;
    <D.31316>:
    D.31303 = cfg->exception_type;
    if (D.31303 == 7) goto <D.31318>; else goto <D.31319>;
    <D.31318>:
    D.31263 = mono_defaults.corlib;
    D.31313 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.31263, "System", "TypeLoadException", D.31313);
    goto <D.31320>;
    <D.31319>:
    D.31303 = cfg->exception_type;
    if (D.31303 == 8) goto <D.31321>; else goto <D.31322>;
    <D.31321>:
    D.31263 = mono_defaults.corlib;
    D.31313 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.31263, "System", "FileNotFoundException", D.31313);
    goto <D.31323>;
    <D.31322>:
    D.31303 = cfg->exception_type;
    if (D.31303 == 12) goto <D.31324>; else goto <D.31325>;
    <D.31324>:
    D.31313 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.31313);
    goto <D.31326>;
    <D.31325>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.31326>:
    <D.31323>:
    <D.31320>:
    <D.31317>:
    <D.31314>:
    <D.31310>:
    <D.31306>:
    goto <D.26620>;
  }
  <D.26627>:
  D.31263 = mono_defaults.corlib;
  D.31313 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.31263, "System", "InvalidProgramException", D.31313);
  goto <D.26620>;
  <D.26628>:
  D.31263 = mono_defaults.corlib;
  D.31313 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.31263, "System.Security", "VerificationException", D.31313);
  goto <D.26620>;
  <D.26629>:
  D.31263 = mono_defaults.corlib;
  D.31313 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.31263, "System", "MethodAccessException", D.31313);
  goto <D.26620>;
  <D.26630>:
  D.31263 = mono_defaults.corlib;
  D.31313 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.31263, "System", "FieldAccessException", D.31313);
  goto <D.26620>;
  <D.26631>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

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

    exp = cfg->exception_ptr;
    D.31329 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.31329);
    ex = exp;
    goto <D.26620>;
  }
  <D.26637>:
  D.31330 = mono_domain_get ();
  ex = D.31330->out_of_memory_ex;
  goto <D.26620>;
  <D.26638>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.26620>:
  if (ex != 0B) goto <D.31331>; else goto <D.31332>;
  <D.31331>:
  D.31333 = cfg->prof_options;
  D.31334 = D.31333 & 16;
  if (D.31334 != 0) goto <D.31335>; else goto <D.31336>;
  <D.31335>:
  method.120 = method;
  mono_profiler_method_end_jit (method.120, 0B, 1);
  <D.31336>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.31047 = 0B;
  return D.31047;
  <D.31332>:
  mono_loader_lock ();
  {
    int ret;

    D.31337 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.31337);
    if (ret != 0) goto <D.31338>; else goto <D.31339>;
    <D.31338>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31339>:
    D.31340 = ret != 0;
    D.31341 = (long int) D.31340;
    D.31342 = __builtin_expect (D.31341, 0);
    if (D.31342 != 0) goto <D.31343>; else goto <D.31344>;
    <D.31343>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.31344>:
  }
  {
    int ret;

    D.31345 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.31345);
    if (ret != 0) goto <D.31346>; else goto <D.31347>;
    <D.31346>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31347>:
    D.31348 = ret != 0;
    D.31349 = (long int) D.31348;
    D.31350 = __builtin_expect (D.31349, 0);
    if (D.31350 != 0) goto <D.31351>; else goto <D.31352>;
    <D.31351>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.31352>:
  }
  method.120 = method;
  info = lookup_method_inner (target_domain, method.120);
  if (info != 0B) goto <D.31353>; else goto <D.31354>;
  <D.31353>:
  D.31357 = mono_domain_get ();
  if (D.31357 == target_domain) goto <D.31355>; else goto <D.31358>;
  <D.31358>:
  D.31359 = BIT_FIELD_REF <*info, 64, 256>;
  D.31360 = D.31359 & 32768;
  if (D.31360 != 0) goto <D.31355>; else goto <D.31356>;
  <D.31355>:
  code = info->code_start;
  <D.31356>:
  <D.31354>:
  if (code == 0B) goto <D.31361>; else goto <D.31362>;
  <D.31361>:
  D.31363 = &target_domain->jit_code_hash;
  D.31364 = cfg->jit_info;
  D.31365 = D.31364->d.method;
  D.31364 = cfg->jit_info;
  mono_internal_hash_table_insert (D.31363, D.31365, D.31364);
  {
    int ret;

    D.31345 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31345);
    if (ret != 0) goto <D.31366>; else goto <D.31367>;
    <D.31366>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31367>:
    D.31368 = ret != 0;
    D.31369 = (long int) D.31368;
    D.31370 = __builtin_expect (D.31369, 0);
    if (D.31370 != 0) goto <D.31371>; else goto <D.31372>;
    <D.31371>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.31372>:
  }
  code = cfg->native_code;
  D.31373 = cfg->generic_sharing_context;
  if (D.31373 != 0B) goto <D.31374>; else goto <D.31375>;
  <D.31374>:
  method.120 = method;
  D.31376 = mono_method_is_generic_sharable (method.120, 0);
  if (D.31376 != 0) goto <D.31377>; else goto <D.31378>;
  <D.31377>:
  D.31379 = mono_stats.generics_shared_methods;
  D.31380 = D.31379 + 1;
  mono_stats.generics_shared_methods = D.31380;
  <D.31378>:
  <D.31375>:
  D.31381 = cfg->gsharedvt;
  if (D.31381 != 0) goto <D.31382>; else goto <D.31383>;
  <D.31382>:
  D.31384 = mono_stats.gsharedvt_methods;
  D.31385 = D.31384 + 1;
  mono_stats.gsharedvt_methods = D.31385;
  <D.31383>:
  goto <D.31386>;
  <D.31362>:
  {
    int ret;

    D.31345 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.31345);
    if (ret != 0) goto <D.31387>; else goto <D.31388>;
    <D.31387>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31388>:
    D.31389 = ret != 0;
    D.31390 = (long int) D.31389;
    D.31391 = __builtin_expect (D.31390, 0);
    if (D.31391 != 0) goto <D.31392>; else goto <D.31393>;
    <D.31392>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.31393>:
  }
  <D.31386>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.31394 = mono_jit_stats.allocate_var;
  D.31395 = cfg->stat_allocate_var;
  D.31396 = D.31394 + D.31395;
  mono_jit_stats.allocate_var = D.31396;
  D.31397 = mono_jit_stats.locals_stack_size;
  D.31398 = cfg->stat_locals_stack_size;
  D.31399 = D.31397 + D.31398;
  mono_jit_stats.locals_stack_size = D.31399;
  D.31400 = mono_jit_stats.basic_blocks;
  D.31401 = cfg->stat_basic_blocks;
  D.31402 = D.31400 + D.31401;
  mono_jit_stats.basic_blocks = D.31402;
  D.31403 = mono_jit_stats.max_basic_blocks;
  D.31401 = cfg->stat_basic_blocks;
  D.31404 = MAX_EXPR <D.31403, D.31401>;
  mono_jit_stats.max_basic_blocks = D.31404;
  D.31405 = mono_jit_stats.cil_code_size;
  D.31406 = cfg->stat_cil_code_size;
  D.31407 = D.31405 + D.31406;
  mono_jit_stats.cil_code_size = D.31407;
  D.31408 = mono_jit_stats.regvars;
  D.31409 = cfg->stat_n_regvars;
  D.31410 = D.31408 + D.31409;
  mono_jit_stats.regvars = D.31410;
  D.31411 = mono_jit_stats.inlineable_methods;
  D.31412 = cfg->stat_inlineable_methods;
  D.31413 = D.31411 + D.31412;
  mono_jit_stats.inlineable_methods = D.31413;
  D.31414 = mono_jit_stats.inlined_methods;
  D.31415 = cfg->stat_inlined_methods;
  D.31416 = D.31414 + D.31415;
  mono_jit_stats.inlined_methods = D.31416;
  D.31417 = mono_jit_stats.cas_demand_generation;
  D.31418 = cfg->stat_cas_demand_generation;
  D.31419 = D.31417 + D.31418;
  mono_jit_stats.cas_demand_generation = D.31419;
  D.31420 = mono_jit_stats.code_reallocs;
  D.31421 = cfg->stat_code_reallocs;
  D.31422 = D.31420 + D.31421;
  mono_jit_stats.code_reallocs = D.31422;
  mono_destroy_compile (cfg);
  D.31423 = target_domain->runtime_info;
  D.31424 = MEM[(struct MonoJitDomainInfo *)D.31423].jump_target_hash;
  if (D.31424 != 0B) goto <D.31425>; else goto <D.31426>;
  <D.31425>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        D.31423 = target_domain->runtime_info;
        D.31424 = MEM[(struct MonoJitDomainInfo *)D.31423].jump_target_hash;
        method.120 = method;
        jlist = monoeg_g_hash_table_lookup (D.31424, method.120);
        if (jlist != 0B) goto <D.31427>; else goto <D.31428>;
        <D.31427>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.120 = method;
        patch_info.data.method = method.120;
        D.31423 = target_domain->runtime_info;
        D.31424 = MEM[(struct MonoJitDomainInfo *)D.31423].jump_target_hash;
        method.120 = method;
        monoeg_g_hash_table_remove (D.31424, method.120);
        tmp = jlist->list;
        goto <D.26647>;
        <D.26646>:
        D.31429 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.31429, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.26647>:
        if (tmp != 0B) goto <D.26646>; else goto <D.26648>;
        <D.26648>:
        <D.31428>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.31426>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.31337 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31337);
    if (ret != 0) goto <D.31430>; else goto <D.31431>;
    <D.31430>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31431>:
    D.31432 = ret != 0;
    D.31433 = (long int) D.31432;
    D.31434 = __builtin_expect (D.31433, 0);
    if (D.31434 != 0) goto <D.31435>; else goto <D.31436>;
    <D.31435>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.31436>:
  }
  mono_loader_unlock ();
  method.120 = method;
  D.31039 = method.120->klass;
  vtable = mono_class_vtable (target_domain, D.31039);
  if (vtable == 0B) goto <D.31437>; else goto <D.31438>;
  <D.31437>:
  method.120 = method;
  D.31039 = method.120->klass;
  ex = mono_class_get_exception_for_failure (D.31039);
  D.31439 = ex == 0B;
  D.31440 = (long int) D.31439;
  D.31441 = __builtin_expect (D.31440, 0);
  if (D.31441 != 0) goto <D.31442>; else goto <D.31443>;
  <D.31442>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6115, "ex");
  <D.31443>:
  *jit_ex = ex;
  D.31047 = 0B;
  return D.31047;
  <D.31438>:
  D.31444 = prof_options & 16;
  if (D.31444 != 0) goto <D.31445>; else goto <D.31446>;
  <D.31445>:
  method.120 = method;
  D.31265 = BIT_FIELD_REF <*method.120, 64, 256>;
  D.31266 = D.31265 & 124;
  if (D.31266 == 24) goto <D.31447>; else goto <D.31448>;
  <D.31447>:
  method.120 = method;
  D.31449 = mono_marshal_method_from_wrapper (method.120);
  if (D.31449 != 0B) goto <D.31450>; else goto <D.31451>;
  <D.31450>:
  method.120 = method;
  D.31452 = mono_marshal_method_from_wrapper (method.120);
  mono_profiler_method_end_jit (D.31452, jinfo, 0);
  <D.31451>:
  <D.31448>:
  method.120 = method;
  mono_profiler_method_end_jit (method.120, jinfo, 0);
  method.120 = method;
  if (prof_method != method.120) goto <D.31453>; else goto <D.31454>;
  <D.31453>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.31454>:
  <D.31446>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.31455>; else goto <D.31456>;
  <D.31455>:
  *jit_ex = ex;
  D.31047 = 0B;
  return D.31047;
  <D.31456>:
  D.31047 = code;
  return D.31047;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.31461;
  unsigned int info_len.132;
  struct GSList * D.31466;
  guint8 * D.31467;
  unsigned int D.31468;
  int D.31469;
  unsigned int info_len.133;
  unsigned int D.31471;
  struct MonoJitInfo * D.31472;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.31461 = info->uw_info;
      if (D.31461 != 0B) goto <D.31462>; else goto <D.31463>;
      <D.31462>:
      uw_info = info->uw_info;
      info_len.132 = info->uw_info_len;
      info_len = info_len.132;
      goto <D.31465>;
      <D.31463>:
      D.31466 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.31466, &info_len);
      <D.31465>:
      jinfo = mono_domain_alloc0 (domain, 48);
      jinfo->d.method = wrapper;
      D.31467 = info->code;
      jinfo->code_start = D.31467;
      D.31468 = info->code_size;
      D.31469 = (int) D.31468;
      jinfo->code_size = D.31469;
      info_len.133 = info_len;
      D.31471 = mono_cache_unwind_info (uw_info, info_len.133);
      jinfo->used_regs = D.31471;
      D.31472 = jinfo;
      return D.31472;
    }
  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.134;
  unsigned int D.31476;
  long unsigned int D.31485;
  long unsigned int D.31486;
  int D.31487;
  int D.31488;
  void * D.31491;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.134 = default_opt;
  D.31476 = default_opt.134 & 512;
  if (D.31476 != 0) goto <D.31477>; else goto <D.31478>;
  <D.31477>:
  target_domain = mono_get_root_domain ();
  goto <D.31479>;
  <D.31478>:
  target_domain = domain;
  <D.31479>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.31480>; else goto <D.31481>;
  <D.31480>:
  if (domain == target_domain) goto <D.31482>; else goto <D.31484>;
  <D.31484>:
  D.31485 = BIT_FIELD_REF <*info, 64, 256>;
  D.31486 = D.31485 & 32768;
  if (D.31486 != 0) goto <D.31482>; else goto <D.31483>;
  <D.31482>:
  D.31487 = mono_jit_stats.methods_lookups;
  D.31488 = D.31487 + 1;
  mono_jit_stats.methods_lookups = D.31488;
  if (ji != 0B) goto <D.31489>; else goto <D.31490>;
  <D.31489>:
  *ji = info;
  <D.31490>:
  D.31491 = info->code_start;
  return D.31491;
  <D.31483>:
  <D.31481>:
  if (ji != 0B) goto <D.31492>; else goto <D.31493>;
  <D.31492>:
  *ji = 0B;
  <D.31493>:
  D.31491 = 0B;
  return D.31491;
}


mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.31495;
  long int D.31496;
  long int D.31497;
  int mono_do_single_method_regression.135;
  guint32 D.31503;
  struct MonoMethod * mono_current_single_method.136;
  struct GHashTable * mono_single_method_hash.137;
  struct GHashTable * mono_single_method_hash.138;
  void * D.31511;
  struct GSList * mono_single_method_list.139;
  struct GSList * mono_single_method_list.140;

  D.31495 = method == 0B;
  D.31496 = (long int) D.31495;
  D.31497 = __builtin_expect (D.31496, 0);
  if (D.31497 != 0) goto <D.31498>; else goto <D.31499>;
  <D.31498>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.31499>:
  mono_do_single_method_regression.135 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.135 == 0) goto <D.31501>; else goto <D.31502>;
  <D.31501>:
  D.31503 = default_opt;
  return D.31503;
  <D.31502>:
  mono_current_single_method.136 = mono_current_single_method;
  if (mono_current_single_method.136 == 0B) goto <D.31505>; else goto <D.31506>;
  <D.31505>:
  mono_single_method_hash.137 = mono_single_method_hash;
  if (mono_single_method_hash.137 == 0B) goto <D.31508>; else goto <D.31509>;
  <D.31508>:
  mono_single_method_hash.138 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = mono_single_method_hash.138;
  <D.31509>:
  mono_single_method_hash.137 = mono_single_method_hash;
  D.31511 = monoeg_g_hash_table_lookup (mono_single_method_hash.137, method);
  if (D.31511 == 0B) goto <D.31512>; else goto <D.31513>;
  <D.31512>:
  mono_single_method_hash.137 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.137, method, method, 0);
  mono_single_method_list.139 = mono_single_method_list;
  mono_single_method_list.140 = monoeg_g_slist_prepend (mono_single_method_list.139, method);
  mono_single_method_list = mono_single_method_list.140;
  <D.31513>:
  D.31503 = default_opt;
  return D.31503;
  <D.31506>:
  mono_current_single_method.136 = mono_current_single_method;
  if (method == mono_current_single_method.136) goto <D.31516>; else goto <D.31517>;
  <D.31516>:
  D.31503 = mono_single_method_regression_opt;
  return D.31503;
  <D.31517>:
  D.31503 = default_opt;
  return D.31503;
}


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

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


mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoDomain * D.31521;
  void * D.31522;
  int D.31525;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.31521 = mono_domain_get ();
  D.31522 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.31521, D.31522);
  exc = mono_get_exception_divide_by_zero ();
  if (ji == 0B) goto <D.31523>; else goto <D.31524>;
  <D.31523>:
  D.31525 = mono_chain_signal (_dummy, info, context);
  if (D.31525 != 0) goto <D.31526>; else goto <D.31527>;
  <D.31526>:
  return;
  <D.31527>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31524>:
  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.141;
  int D.31530;
  int D.31533;
  void * D.31536;
  int D.31537;
  struct MonoDomain * D.31542;
  int D.31544;
  struct MonoDomain * D.31547;
  void * D.31548;
  int D.31551;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.141 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.141);
  fault_addr = 0B;
  ctx = context;
  D.31530 = mono_arch_is_single_step_event (info, ctx);
  if (D.31530 != 0) goto <D.31531>; else goto <D.31532>;
  <D.31531>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.31532>:
  D.31533 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.31533 != 0) goto <D.31534>; else goto <D.31535>;
  <D.31534>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.31535>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.31536 = info->_sifields._sigfault.si_addr;
  D.31537 = mono_aot_is_pagefault (D.31536);
  if (D.31537 != 0) goto <D.31538>; else goto <D.31539>;
  <D.31538>:
  D.31536 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.31536);
  return;
  <D.31539>:
  D.31542 = mono_domain_get ();
  if (D.31542 == 0B) goto <D.31540>; else goto <D.31543>;
  <D.31543>:
  if (jit_tls == 0B) goto <D.31540>; else goto <D.31541>;
  <D.31540>:
  D.31544 = mono_chain_signal (_dummy, info, context);
  if (D.31544 != 0) goto <D.31545>; else goto <D.31546>;
  <D.31545>:
  return;
  <D.31546>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31541>:
  D.31547 = mono_domain_get ();
  D.31548 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.31547, D.31548);
  if (ji == 0B) goto <D.31549>; else goto <D.31550>;
  <D.31549>:
  D.31551 = mono_chain_signal (_dummy, info, context);
  if (D.31551 != 0) goto <D.31552>; else goto <D.31553>;
  <D.31552>:
  return;
  <D.31553>:
  mono_handle_native_sigsegv (11, ctx);
  <D.31550>:
  mono_arch_handle_exception (ctx, 0B);
}


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.31555;
  long int D.31556;
  long int D.31557;
  void * * vtable_trampolines.142;
  int D.31564;
  int vtable_trampolines_size.143;
  _Bool D.31568;
  long int D.31569;
  long int D.31570;
  int iftmp.144;
  long unsigned int D.31580;
  long unsigned int D.31581;
  long unsigned int D.31584;
  long unsigned int D.31585;
  _Bool D.31588;
  long int D.31589;
  long int D.31590;
  long unsigned int D.31593;
  long unsigned int D.31594;
  void * * D.31595;
  void * D.31596;
  long unsigned int D.31599;
  void * D.31600;
  struct MonoDomain * D.31601;
  void * D.31602;
  void * D.31603;
  int index;

  index = slot_index + 19;
  D.31555 = slot_index < -19;
  D.31556 = (long int) D.31555;
  D.31557 = __builtin_expect (D.31556, 0);
  if (D.31557 != 0) goto <D.31558>; else goto <D.31559>;
  <D.31558>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.31559>:
  vtable_trampolines.142 = vtable_trampolines;
  if (vtable_trampolines.142 == 0B) goto <D.31560>; else goto <D.31563>;
  <D.31563>:
  D.31564 = slot_index + 19;
  vtable_trampolines_size.143 = vtable_trampolines_size;
  if (D.31564 >= vtable_trampolines_size.143) goto <D.31560>; else goto <D.31561>;
  <D.31560>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31566>; else goto <D.31567>;
    <D.31566>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31567>:
    D.31568 = ret != 0;
    D.31569 = (long int) D.31568;
    D.31570 = __builtin_expect (D.31569, 0);
    if (D.31570 != 0) goto <D.31571>; else goto <D.31572>;
    <D.31571>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.31572>:
  }
  vtable_trampolines.142 = vtable_trampolines;
  if (vtable_trampolines.142 == 0B) goto <D.31573>; else goto <D.31575>;
  <D.31575>:
  vtable_trampolines_size.143 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.143) goto <D.31573>; else goto <D.31574>;
  <D.31573>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.143 = vtable_trampolines_size;
    if (vtable_trampolines_size.143 != 0) goto <D.31577>; else goto <D.31578>;
    <D.31577>:
    vtable_trampolines_size.143 = vtable_trampolines_size;
    iftmp.144 = vtable_trampolines_size.143 * 2;
    goto <D.31579>;
    <D.31578>:
    iftmp.144 = 128;
    <D.31579>:
    new_size = iftmp.144;
    goto <D.26798>;
    <D.26797>:
    new_size = new_size * 2;
    <D.26798>:
    if (new_size <= index) goto <D.26797>; else goto <D.26799>;
    <D.26799>:
    D.31580 = (long unsigned int) new_size;
    D.31581 = D.31580 * 8;
    new_table = monoeg_malloc0 (D.31581);
    vtable_trampolines.142 = vtable_trampolines;
    if (vtable_trampolines.142 != 0B) goto <D.31582>; else goto <D.31583>;
    <D.31582>:
    vtable_trampolines.142 = vtable_trampolines;
    vtable_trampolines_size.143 = vtable_trampolines_size;
    D.31584 = (long unsigned int) vtable_trampolines_size.143;
    D.31585 = D.31584 * 8;
    memcpy (new_table, vtable_trampolines.142, D.31585);
    <D.31583>:
    vtable_trampolines.142 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.142);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.31574>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.31586>; else goto <D.31587>;
    <D.31586>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31587>:
    D.31588 = ret != 0;
    D.31589 = (long int) D.31588;
    D.31590 = __builtin_expect (D.31589, 0);
    if (D.31590 != 0) goto <D.31591>; else goto <D.31592>;
    <D.31591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.31592>:
  }
  <D.31561>:
  vtable_trampolines.142 = vtable_trampolines;
  D.31593 = (long unsigned int) index;
  D.31594 = D.31593 * 8;
  D.31595 = vtable_trampolines.142 + D.31594;
  D.31596 = *D.31595;
  if (D.31596 == 0B) goto <D.31597>; else goto <D.31598>;
  <D.31597>:
  vtable_trampolines.142 = vtable_trampolines;
  D.31593 = (long unsigned int) index;
  D.31594 = D.31593 * 8;
  D.31595 = vtable_trampolines.142 + D.31594;
  D.31599 = (long unsigned int) slot_index;
  D.31600 = (void *) D.31599;
  D.31601 = mono_get_root_domain ();
  D.31602 = mono_create_specific_trampoline (D.31600, 12, D.31601, 0B);
  *D.31595 = D.31602;
  <D.31598>:
  vtable_trampolines.142 = vtable_trampolines;
  D.31593 = (long unsigned int) index;
  D.31594 = D.31593 * 8;
  D.31595 = vtable_trampolines.142 + D.31594;
  D.31603 = *D.31595;
  return D.31603;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mini_get_debug_options ()
{
  struct MonoDebugOptions * D.31605;

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


mini_init (const char * filename, const char * runtime_version)
{
  int D.31607;
  int default_opt_set.145;
  int D.31613;
  unsigned int default_opt.146;
  struct MonoCodeManager * global_codeman.147;
  struct MonoCodeManager * global_codeman.148;
  struct GHashTable * jit_icall_name_hash.149;
  int mono_use_imt.150;
  const gchar * D.31623;
  const gchar * D.31626;
  struct MonoDebugOptions * D.31630;
  int D.31631;
  unsigned int default_opt.151;
  unsigned int D.31639;
  int D.31642;
  int mono_aot_only.152;
  struct MonoCodeManager * D.31651;
  void * D.31657;
  void * D.31658;
  void * D.31659;
  int mono_compile_aot.153;
  struct MonoDomain * D.31663;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.31607 = access ("/proc/self/maps", 0);
      if (D.31607 != 0) goto <D.31608>; else goto <D.31609>;
      <D.31608>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.31609>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.145 = default_opt_set;
      if (default_opt_set.145 == 0) goto <D.31611>; else goto <D.31612>;
      <D.31611>:
      D.31613 = mono_parse_default_optimizations (0B);
      default_opt.146 = (unsigned int) D.31613;
      default_opt = default_opt.146;
      <D.31612>:
      mono_runtime_set_has_tls_get (1);
      global_codeman.147 = global_codeman;
      if (global_codeman.147 == 0B) goto <D.31616>; else goto <D.31617>;
      <D.31616>:
      global_codeman.148 = mono_code_manager_new ();
      global_codeman = global_codeman.148;
      <D.31617>:
      jit_icall_name_hash.149 = 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.149;
      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.150 = mono_use_imt;
      if (mono_use_imt.150 != 0) goto <D.31621>; else goto <D.31622>;
      <D.31621>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.31622>:
      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.31623 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.31623 != 0B) goto <D.31624>; else goto <D.31625>;
      <D.31624>:
      mini_parse_debug_options ();
      <D.31625>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.31626 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.31626 != 0B) goto <D.31627>; else goto <D.31628>;
      <D.31627>:
      {
        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.31629>;
      <D.31628>:
      D.31630 = mini_get_debug_options ();
      D.31631 = D.31630->gdb;
      if (D.31631 != 0) goto <D.31632>; else goto <D.31633>;
      <D.31632>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.31633>:
      <D.31629>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.31634>; else goto <D.31635>;
      <D.31634>:
      if (0 != 0) goto <D.31636>; else goto <D.31637>;
      <D.31636>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.27023>:
      goto <D.27023>;
      <D.31637>:
      <D.31635>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.151 = default_opt;
      D.31639 = default_opt.151 & 65536;
      if (D.31639 != 0) goto <D.31640>; else goto <D.31641>;
      <D.31640>:
      mono_aot_init ();
      <D.31641>:
      mono_debugger_agent_init ();
      mono_set_generic_sharing_supported (1);
      mono_runtime_install_handlers ();
      mono_threads_install_cleanup (mini_thread_cleanup);
      mono_install_compile_method (mono_jit_compile_method);
      mono_install_free_method (mono_jit_free_method);
      mono_install_trampoline (mono_create_jit_trampoline);
      mono_install_jump_trampoline (mono_create_jump_trampoline);
      mono_install_remoting_trampoline (mono_jit_create_remoting_trampoline);
      mono_install_delegate_trampoline (mono_create_delegate_trampoline);
      mono_install_create_domain_hook (mini_create_jit_domain_info);
      mono_install_free_domain_hook (mini_free_jit_domain_info);
      mono_install_runtime_invoke (mono_jit_runtime_invoke);
      mono_install_get_cached_class_info (mono_aot_get_cached_class_info);
      mono_install_get_class_from_name (mono_aot_get_class_from_name);
      mono_install_jit_info_find_in_aot (mono_aot_find_jit_info);
      D.31642 = debug_options.collect_pagefault_stats;
      if (D.31642 != 0) goto <D.31643>; else goto <D.31644>;
      <D.31643>:
      mono_aot_set_make_unreadable (1);
      <D.31644>:
      if (runtime_version != 0B) goto <D.31645>; else goto <D.31646>;
      <D.31645>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.31647>;
      <D.31646>:
      domain = mono_init_from_assembly (filename, filename);
      <D.31647>:
      mono_aot_only.152 = mono_aot_only;
      if (mono_aot_only.152 != 0) goto <D.31649>; else goto <D.31650>;
      <D.31649>:
      D.31651 = domain->code_mp;
      mono_code_manager_set_read_only (D.31651);
      mono_marshal_use_aot_wrappers (1);
      <D.31650>:
      mono_use_imt.150 = mono_use_imt;
      if (mono_use_imt.150 != 0) goto <D.31652>; else goto <D.31653>;
      <D.31652>:
      mono_aot_only.152 = mono_aot_only;
      if (mono_aot_only.152 != 0) goto <D.31654>; else goto <D.31655>;
      <D.31654>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.31656>;
      <D.31655>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.31656>:
      <D.31653>:
      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.31657 = mono_get_throw_exception ();
      register_dyn_icall (D.31657, "mono_arch_throw_exception", "void object", 1);
      D.31658 = mono_get_rethrow_exception ();
      register_dyn_icall (D.31658, "mono_arch_rethrow_exception", "void object", 1);
      D.31659 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.31659, "mono_arch_throw_corlib_exception", "void ptr", 1);
      register_icall (mono_thread_get_undeniable_exception, "mono_thread_get_undeniable_exception", "object", 0);
      register_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", "void", 0);
      register_icall (mono_thread_force_interruption_checkpoint, "mono_thread_force_interruption_checkpoint", "void", 0);
      register_icall (mono_load_remote_field_new, "mono_load_remote_field_new", "object object ptr ptr", 0);
      register_icall (mono_store_remote_field_new, "mono_store_remote_field_new", "void object ptr ptr object", 0);
      register_opcode_emulation (684, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, "mono_fconv_u8", 0);
      register_opcode_emulation (683, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 0);
      register_opcode_emulation (712, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, "mono_fconv_ovf_i8", 0);
      register_opcode_emulation (713, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, "mono_fconv_ovf_u8", 0);
      register_opcode_emulation (536, "__emul_lconv_to_r8_un", "double long", mono_lconv_to_r8_un, "mono_lconv_to_r8_un", 0);
      register_opcode_emulation (673, "__emul_frem", "double double double", fmod, "fmod", 0);
      register_opcode_emulation (727, "__emul_fconv_to_u", "ulong double", mono_fconv_u8, "mono_fconv_u8", 1);
      register_icall (mono_delegate_ctor, "mono_delegate_ctor", "void object object ptr", 0);
      register_icall (mono_class_static_field_address, "mono_class_static_field_address", "ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper, "mono_ldtoken_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_ldtoken_wrapper_generic_shared, "mono_ldtoken_wrapper_generic_shared", "ptr ptr ptr ptr", 0);
      register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", 0);
      register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", 0);
      register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", 0);
      register_icall (mono_object_new, "mono_object_new", "object ptr ptr", 0);
      register_icall (mono_object_new_specific, "mono_object_new_specific", "object ptr", 0);
      register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", 0);
      register_icall (mono_array_new_specific, "mono_array_new_specific", "object ptr int32", 0);
      register_icall (mono_runtime_class_init, "mono_runtime_class_init", "void ptr", 0);
      register_icall (mono_ldftn, "mono_ldftn", "ptr ptr", 0);
      register_icall (mono_ldvirtfn, "mono_ldvirtfn", "ptr object ptr", 0);
      register_icall (mono_ldvirtfn_gshared, "mono_ldvirtfn_gshared", "ptr object ptr", 0);
      register_icall (mono_helper_compile_generic_method, "mono_helper_compile_generic_method", "ptr object ptr ptr", 0);
      register_icall (mono_helper_ldstr, "mono_helper_ldstr", "object ptr int", 0);
      register_icall (mono_helper_ldstr_mscorlib, "mono_helper_ldstr_mscorlib", "object int", 0);
      register_icall (mono_helper_newobj_mscorlib, "mono_helper_newobj_mscorlib", "object int", 0);
      register_icall (mono_value_copy, "mono_value_copy", "void ptr ptr ptr", 0);
      register_icall (mono_object_castclass_unbox, "mono_object_castclass_unbox", "object object ptr", 0);
      register_icall (mono_break, "mono_break", 0B, 1);
      register_icall (mono_create_corlib_exception_0, "mono_create_corlib_exception_0", "object int", 1);
      register_icall (mono_create_corlib_exception_1, "mono_create_corlib_exception_1", "object int object", 1);
      register_icall (mono_create_corlib_exception_2, "mono_create_corlib_exception_2", "object int object object", 1);
      register_icall (mono_array_new_1, "mono_array_new_1", "object ptr int", 0);
      register_icall (mono_array_new_2, "mono_array_new_2", "object ptr int int", 0);
      register_icall (mono_array_new_3, "mono_array_new_3", "object ptr int int int", 0);
      register_icall (mono_array_new_4, "mono_array_new_4", "object ptr int int int int", 0);
      register_icall (mono_get_native_calli_wrapper, "mono_get_native_calli_wrapper", "ptr ptr ptr ptr", 0);
      register_icall (mono_resume_unwind, "mono_resume_unwind", "void", 1);
      register_icall (mono_gsharedvt_constrained_call, "mono_gsharedvt_constrained_call", "object ptr ptr ptr ptr ptr", 0);
      register_icall (mono_gsharedvt_value_copy, "mono_gsharedvt_value_copy", "void ptr ptr ptr", 1);
      register_icall (mono_gc_wbarrier_value_copy_bitmap, "mono_gc_wbarrier_value_copy_bitmap", "void ptr ptr int int", 0);
      register_icall (mono_object_castclass_with_cache, "mono_object_castclass_with_cache", "object object ptr ptr", 0);
      register_icall (mono_object_isinst_with_cache, "mono_object_isinst_with_cache", "object object ptr ptr", 0);
      register_icall (mono_debugger_agent_user_break, "mono_debugger_agent_user_break", "void", 0);
      mono_generic_sharing_init ();
      mono_compile_aot.153 = mono_compile_aot;
      if (mono_compile_aot.153 != 0) goto <D.31661>; else goto <D.31662>;
      <D.31661>:
      mono_runtime_set_no_exec (1);
      <D.31662>:
      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.31663 = domain;
      return D.31663;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.31668;
  unsigned int D.31669;
  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.31666>; else goto <D.31667>;
  <D.31666>:
  thread->jit_data = jit_tls;
  <D.31667>:
  D.31668 = mono_profiler_get_events ();
  D.31669 = D.31668 & 32768;
  if (D.31669 != 0) goto <D.31670>; else goto <D.31671>;
  <D.31670>:
  mono_runtime_setup_stat_profiler ();
  <D.31671>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T3694>) (struct MonoObject *) mono_thread_attach_aborted_cb.154;

  mono_thread_attach_aborted_cb.154 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.154 != 0B) goto <D.31673>; else goto <D.31674>;
  <D.31673>:
  mono_thread_attach_aborted_cb.154 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.154 (obj);
  goto <D.31675>;
  <D.31674>:
  mono_thread_abort (obj);
  <D.31675>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.31679;
  struct MonoVTable * D.31681;
  struct MonoClass * D.31682;
  struct MonoClass * D.31683;

  D.31679 = mono_runtime_unhandled_exception_policy_get ();
  if (D.31679 == 0) goto <D.31676>; else goto <D.31680>;
  <D.31680>:
  D.31681 = obj->vtable;
  D.31682 = D.31681->klass;
  D.31683 = mono_defaults.threadabortexception_class;
  if (D.31682 == D.31683) goto <D.31676>; else goto <D.31677>;
  <D.31676>:
  mono_thread_exit ();
  goto <D.31678>;
  <D.31677>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.31678>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.155;
  void * D.31687;
  void (*<T3694>) (struct MonoObject *) abort_func.156;
  struct MonoLMF * * D.31689;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.155 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.155);
  if (jit_tls != 0B) goto <D.31685>; else goto <D.31686>;
  <D.31685>:
  D.31687 = jit_tls;
  return D.31687;
  <D.31686>:
  jit_tls = monoeg_malloc0 (1728);
  abort_func.156 = (void (*<T3694>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.156;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (344);
  lmf->ebp = 18446744073709551615;
  jit_tls->first_lmf = lmf;
  D.31689 = &jit_tls->lmf;
  mono_set_lmf_addr (D.31689);
  jit_tls->lmf = lmf;
  mono_setup_altstack (jit_tls);
  D.31687 = jit_tls;
  return D.31687;
}


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

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


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.31692;
  int D.31693;
  _Bool D.31694;

  D.31693 = pthread_setspecific (key, value);
  D.31694 = D.31693 == 0;
  D.31692 = (int) D.31694;
  return D.31692;
}


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


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  short unsigned int D.31700;
  int D.31701;
  int D.31702;
  long unsigned int D.31705;
  long unsigned int D.31706;
  struct MonoObject * D.31709;
  union mono_mutex_t * D.31710;
  _Bool D.31713;
  long int D.31714;
  long int D.31715;
  struct GHashTable * D.31718;
  _Bool D.31721;
  long int D.31722;
  long int D.31723;
  <unnamed type> D.31728;
  struct MonoClass * D.31731;
  unsigned char D.31732;
  struct MonoException * D.31737;
  struct MonoException * D.31739;
  struct MonoVTable * D.31740;
  struct MonoVTable * D.31741;
  _Bool D.31742;
  long int D.31743;
  long int D.31744;
  unsigned char D.31747;
  short unsigned int D.31750;
  unsigned int D.31751;
  unsigned int D.31752;
  int mono_aot_only.158;
  unsigned int default_opt.159;
  unsigned int D.31762;
  void * D.31763;
  void * D.31764;
  struct MonoException * jit_ex.160;
  _Bool D.31768;
  long int D.31769;
  long int D.31770;
  int D.31775;
  void * D.31776;
  struct MonoDynCallInfo * D.31778;
  void * D.31781;
  _Bool D.31784;
  long int D.31785;
  long int D.31786;
  _Bool D.31794;
  long int D.31795;
  long int D.31796;
  void * D.31799;
  struct MonoException * D.31802;
  struct MonoObject * D.31803;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T3301>) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;
  struct MonoDomain * domain;
  struct MonoJitDomainInfo * domain_info;
  struct RuntimeInvokeInfo * info;
  struct RuntimeInvokeInfo * info2;

  domain = mono_domain_get ();
  if (obj == 0B) goto <D.31698>; else goto <D.31699>;
  <D.31698>:
  D.31700 = method->flags;
  D.31701 = (int) D.31700;
  D.31702 = D.31701 & 16;
  if (D.31702 == 0) goto <D.31703>; else goto <D.31704>;
  <D.31703>:
  D.31705 = BIT_FIELD_REF <*method, 64, 256>;
  D.31706 = D.31705 & 252;
  if (D.31706 == 0) goto <D.31707>; else goto <D.31708>;
  <D.31707>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.31709 = 0B;
  return D.31709;
  <D.31708>:
  <D.31704>:
  <D.31699>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.31710 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31710);
    if (ret != 0) goto <D.31711>; else goto <D.31712>;
    <D.31711>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31712>:
    D.31713 = ret != 0;
    D.31714 = (long int) D.31713;
    D.31715 = __builtin_expect (D.31714, 0);
    if (D.31715 != 0) goto <D.31716>; else goto <D.31717>;
    <D.31716>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.31717>:
  }
  D.31718 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.31718, method);
  {
    int ret;

    D.31710 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31710);
    if (ret != 0) goto <D.31719>; else goto <D.31720>;
    <D.31719>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31720>:
    D.31721 = ret != 0;
    D.31722 = (long int) D.31721;
    D.31723 = __builtin_expect (D.31722, 0);
    if (D.31723 != 0) goto <D.31724>; else goto <D.31725>;
    <D.31724>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.31725>:
  }
  if (info == 0B) goto <D.31726>; else goto <D.31727>;
  <D.31726>:
  D.31728 = mono_security_get_mode ();
  if (D.31728 == 1) goto <D.31729>; else goto <D.31730>;
  <D.31729>:
  D.31731 = method->klass;
  mono_class_setup_vtable (D.31731);
  D.31731 = method->klass;
  D.31732 = D.31731->exception_type;
  if (D.31732 != 0) goto <D.31733>; else goto <D.31734>;
  <D.31733>:
  if (exc != 0B) goto <D.31735>; else goto <D.31736>;
  <D.31735>:
  D.31731 = method->klass;
  D.31737 = mono_class_get_exception_for_failure (D.31731);
  *exc = D.31737;
  goto <D.31738>;
  <D.31736>:
  D.31731 = method->klass;
  D.31739 = mono_class_get_exception_for_failure (D.31731);
  mono_raise_exception (D.31739);
  <D.31738>:
  D.31709 = 0B;
  return D.31709;
  <D.31734>:
  <D.31730>:
  info = monoeg_malloc0 (48);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.31731 = method->klass;
  D.31740 = mono_class_vtable_full (domain, D.31731, 1);
  info->vtable = D.31740;
  D.31741 = info->vtable;
  D.31742 = D.31741 == 0B;
  D.31743 = (long int) D.31742;
  D.31744 = __builtin_expect (D.31743, 0);
  if (D.31744 != 0) goto <D.31745>; else goto <D.31746>;
  <D.31745>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.31746>:
  callee = method;
  D.31731 = method->klass;
  D.31747 = D.31731->rank;
  if (D.31747 != 0) goto <D.31748>; else goto <D.31749>;
  <D.31748>:
  D.31750 = method->iflags;
  D.31751 = (unsigned int) D.31750;
  D.31752 = D.31751 & 4097;
  if (D.31752 == 4097) goto <D.31753>; else goto <D.31754>;
  <D.31753>:
  mono_aot_only.158 = mono_aot_only;
  if (mono_aot_only.158 != 0) goto <D.31756>; else goto <D.31757>;
  <D.31756>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.31758>;
  <D.31757>:
  callee = 0B;
  <D.31758>:
  <D.31754>:
  <D.31749>:
  if (callee != 0B) goto <D.31759>; else goto <D.31760>;
  <D.31759>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.159 = default_opt;
        D.31762 = mono_get_optimizations_for_method (callee, default_opt.159);
        D.31763 = mono_jit_compile_method_with_opt (callee, D.31762, &jit_ex);
        info->compiled_method = D.31763;
        D.31764 = info->compiled_method;
        if (D.31764 == 0B) goto <D.31765>; else goto <D.31766>;
        <D.31765>:
        monoeg_g_free (info);
        jit_ex.160 = jit_ex;
        D.31768 = jit_ex.160 == 0B;
        D.31769 = (long int) D.31768;
        D.31770 = __builtin_expect (D.31769, 0);
        if (D.31770 != 0) goto <D.31771>; else goto <D.31772>;
        <D.31771>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.31772>:
        if (exc != 0B) goto <D.31773>; else goto <D.31774>;
        <D.31773>:
        jit_ex.160 = jit_ex;
        *exc = jit_ex.160;
        D.31709 = 0B;
        return D.31709;
        <D.31774>:
        jit_ex.160 = jit_ex;
        mono_raise_exception (jit_ex.160);
        <D.31766>:
        D.31764 = info->compiled_method;
        D.31775 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.31776 = mini_add_method_trampoline (0B, callee, D.31764, D.31775, 0);
        info->compiled_method = D.31776;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.31777>;
  <D.31760>:
  info->compiled_method = 0B;
  <D.31777>:
  D.31778 = info->dyn_call_info;
  if (D.31778 == 0B) goto <D.31779>; else goto <D.31780>;
  <D.31779>:
  D.31781 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.31781;
  <D.31780>:
  {
    int ret;

    D.31710 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31710);
    if (ret != 0) goto <D.31782>; else goto <D.31783>;
    <D.31782>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31783>:
    D.31784 = ret != 0;
    D.31785 = (long int) D.31784;
    D.31786 = __builtin_expect (D.31785, 0);
    if (D.31786 != 0) goto <D.31787>; else goto <D.31788>;
    <D.31787>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.31788>:
  }
  D.31718 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.31718, method);
  if (info2 != 0B) goto <D.31789>; else goto <D.31790>;
  <D.31789>:
  monoeg_g_free (info);
  info = info2;
  goto <D.31791>;
  <D.31790>:
  D.31718 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.31718, method, info, 0);
  <D.31791>:
  {
    int ret;

    D.31710 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31710);
    if (ret != 0) goto <D.31792>; else goto <D.31793>;
    <D.31792>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31793>:
    D.31794 = ret != 0;
    D.31795 = (long int) D.31794;
    D.31796 = __builtin_expect (D.31795, 0);
    if (D.31796 != 0) goto <D.31797>; else goto <D.31798>;
    <D.31797>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6587, "ret == 0");
    <D.31798>:
  }
  <D.31727>:
  D.31799 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T3301>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.31799;
  if (exc != 0B) goto <D.31800>; else goto <D.31801>;
  <D.31800>:
  D.31741 = info->vtable;
  D.31802 = mono_runtime_class_init_full (D.31741, 0);
  *exc = D.31802;
  D.31803 = *exc;
  if (D.31803 != 0B) goto <D.31804>; else goto <D.31805>;
  <D.31804>:
  D.31709 = 0B;
  return D.31709;
  <D.31805>:
  goto <D.31806>;
  <D.31801>:
  D.31741 = info->vtable;
  mono_runtime_class_init (D.31741);
  <D.31806>:
  if (exc != 0B) goto <D.31807>; else goto <D.31808>;
  <D.31807>:
  *exc = 0B;
  <D.31808>:
  D.31764 = info->compiled_method;
  D.31709 = runtime_invoke (obj, params, exc, D.31764);
  return D.31709;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31812;
  struct GHashTable * D.31813;
  struct GHashTable * D.31816;
  struct GHashTable * D.31819;
  struct GHashTable * D.31822;
  struct GHashTable * D.31823;
  struct GHashTable * D.31824;
  struct GHashTable * D.31825;
  struct GHashTable * D.31826;
  struct GHashTable * D.31829;
  struct GHashTable * D.31830;
  struct GHashTable * D.31831;
  struct GHashTable * D.31832;
  void * D.31833;
  struct GHashTable * D.31836;
  void * D.31839;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.31812 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.31812, delete_jump_list, 0B);
  D.31812 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.31812);
  D.31813 = info->jump_target_got_slot_hash;
  if (D.31813 != 0B) goto <D.31814>; else goto <D.31815>;
  <D.31814>:
  D.31813 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.31813, delete_got_slot_list, 0B);
  D.31813 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.31813);
  <D.31815>:
  D.31816 = info->dynamic_code_hash;
  if (D.31816 != 0B) goto <D.31817>; else goto <D.31818>;
  <D.31817>:
  D.31816 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.31816, dynamic_method_info_free, 0B);
  D.31816 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.31816);
  <D.31818>:
  D.31819 = info->method_code_hash;
  if (D.31819 != 0B) goto <D.31820>; else goto <D.31821>;
  <D.31820>:
  D.31819 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.31819);
  <D.31821>:
  D.31822 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31822);
  D.31823 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31823);
  D.31824 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31824);
  D.31825 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31825);
  D.31826 = info->static_rgctx_trampoline_hash;
  if (D.31826 != 0B) goto <D.31827>; else goto <D.31828>;
  <D.31827>:
  D.31826 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31826);
  <D.31828>:
  D.31829 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.31829);
  D.31830 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.31830);
  D.31831 = info->seq_points;
  monoeg_g_hash_table_destroy (D.31831);
  D.31832 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.31832);
  D.31833 = info->agent_info;
  if (D.31833 != 0B) goto <D.31834>; else goto <D.31835>;
  <D.31834>:
  mono_debugger_agent_free_domain_info (domain);
  <D.31835>:
  D.31836 = info->gsharedvt_arg_tramp_hash;
  if (D.31836 != 0B) goto <D.31837>; else goto <D.31838>;
  <D.31837>:
  D.31836 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.31836);
  <D.31838>:
  D.31839 = domain->runtime_info;
  monoeg_g_free (D.31839);
  domain->runtime_info = 0B;
}


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

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

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


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.31842;
  struct GHashTable * D.31843;
  struct GHashTable * D.31844;
  struct GHashTable * D.31845;
  struct GHashTable * D.31846;
  struct GHashTable * D.31847;
  struct GHashTable * D.31848;
  struct GHashTable * D.31849;
  struct GHashTable * D.31850;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (392);
  D.31842 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.31842;
  D.31843 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.31843;
  D.31844 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.31844;
  D.31845 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.31845;
  D.31846 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.31846;
  D.31847 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.31847;
  D.31848 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.31848;
  D.31849 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.31849;
  D.31850 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.31850;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.31851;
  int D.31852;
  int i;
  struct MonoSeqPointInfo * info;

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

    sp = &info->seq_points[i];
    D.31851 = sp->next;
    monoeg_g_free (D.31851);
  }
  i = i + 1;
  <D.27009>:
  D.31852 = info->len;
  if (D.31852 > i) goto <D.27008>; else goto <D.27010>;
  <D.27010>:
  monoeg_g_free (info);
}


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

  info = value;
  monoeg_g_free (info);
}


mono_jit_create_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  short unsigned int D.31853;
  int D.31854;
  int D.31855;
  struct MonoMethodSignature * D.31858;
  short unsigned int D.31859;
  void * D.31862;
  int D.31866;
  struct MonoMethodSignature * D.31868;
  long unsigned int D.31869;
  long unsigned int D.31870;
  struct MonoClass * D.31872;
  long unsigned int D.31873;
  long unsigned int D.31874;
  struct MonoClass * D.31876;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.31853 = method->flags;
  D.31854 = (int) D.31853;
  D.31855 = D.31854 & 64;
  if (D.31855 != 0) goto <D.31856>; else goto <D.31857>;
  <D.31856>:
  D.31858 = mono_method_signature (method);
  D.31859 = D.31858->generic_param_count;
  if (D.31859 != 0) goto <D.31860>; else goto <D.31861>;
  <D.31860>:
  D.31862 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.31862;
  <D.31861>:
  <D.31857>:
  D.31853 = method->flags;
  D.31854 = (int) D.31853;
  D.31866 = D.31854 & 1024;
  if (D.31866 != 0) goto <D.31863>; else goto <D.31867>;
  <D.31867>:
  D.31868 = mono_method_signature (method);
  D.31869 = BIT_FIELD_REF <*D.31868, 64, 64>;
  D.31870 = D.31869 & 18014398509481984;
  if (D.31870 != 0) goto <D.31871>; else goto <D.31864>;
  <D.31871>:
  D.31872 = method->klass;
  D.31873 = BIT_FIELD_REF <*D.31872, 64, 256>;
  D.31874 = D.31873 & 4194304;
  if (D.31874 != 0) goto <D.31863>; else goto <D.31875>;
  <D.31875>:
  D.31872 = method->klass;
  D.31876 = mono_defaults.object_class;
  if (D.31872 == D.31876) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.31865>;
  <D.31864>:
  addr = mono_compile_method (method);
  <D.31865>:
  D.31862 = mono_get_addr_from_ftnptr (addr);
  return D.31862;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  long unsigned int D.31878;
  long unsigned int D.31879;
  _Bool D.31880;
  long int D.31881;
  long int D.31882;
  union mono_mutex_t * D.31885;
  _Bool D.31888;
  long int D.31889;
  long int D.31890;
  _Bool D.31895;
  long int D.31896;
  long int D.31897;
  _Bool D.31904;
  long int D.31905;
  long int D.31906;
  void * D.31909;
  struct GHashTable * D.31910;
  struct MonoInternalHashTable * D.31911;
  struct GHashTable * D.31912;
  struct GHashTable * D.31913;
  struct GHashTable * D.31914;
  struct MonoJumpList * jlist.161;
  struct MonoJitInfo * D.31916;
  void * D.31917;
  int D.31920;
  sizetype D.31921;
  guint8 * D.31922;
  struct GSList * D.31925;
  void * D.31926;
  struct GSList * D.31927;
  int D.31928;
  _Bool D.31931;
  long int D.31932;
  long int D.31933;
  struct MonoCodeManager * D.31938;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.31878 = BIT_FIELD_REF <*method, 64, 256>;
      D.31879 = D.31878 & 512;
      D.31880 = D.31879 == 0;
      D.31881 = (long int) D.31880;
      D.31882 = __builtin_expect (D.31881, 0);
      if (D.31882 != 0) goto <D.31883>; else goto <D.31884>;
      <D.31883>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.31884>:
      {
        int ret;

        D.31885 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31885);
        if (ret != 0) goto <D.31886>; else goto <D.31887>;
        <D.31886>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31887>:
        D.31888 = ret != 0;
        D.31889 = (long int) D.31888;
        D.31890 = __builtin_expect (D.31889, 0);
        if (D.31890 != 0) goto <D.31891>; else goto <D.31892>;
        <D.31891>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.31892>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.31885 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31885);
        if (ret != 0) goto <D.31893>; else goto <D.31894>;
        <D.31893>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31894>:
        D.31895 = ret != 0;
        D.31896 = (long int) D.31895;
        D.31897 = __builtin_expect (D.31896, 0);
        if (D.31897 != 0) goto <D.31898>; else goto <D.31899>;
        <D.31898>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.31899>:
      }
      if (ji == 0B) goto <D.31900>; else goto <D.31901>;
      <D.31900>:
      return;
      <D.31901>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.31885 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31885);
        if (ret != 0) goto <D.31902>; else goto <D.31903>;
        <D.31902>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31903>:
        D.31904 = ret != 0;
        D.31905 = (long int) D.31904;
        D.31906 = __builtin_expect (D.31905, 0);
        if (D.31906 != 0) goto <D.31907>; else goto <D.31908>;
        <D.31907>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.31908>:
      }
      D.31909 = domain->runtime_info;
      D.31910 = MEM[(struct MonoJitDomainInfo *)D.31909].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.31910, method);
      D.31911 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.31911, method);
      D.31909 = domain->runtime_info;
      D.31912 = MEM[(struct MonoJitDomainInfo *)D.31909].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.31912, method);
      D.31909 = domain->runtime_info;
      D.31913 = MEM[(struct MonoJitDomainInfo *)D.31909].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.31913, method);
      D.31909 = domain->runtime_info;
      D.31914 = MEM[(struct MonoJitDomainInfo *)D.31909].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.31914);
      goto <D.26696>;
      <D.26695>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.161 = jlist;
        tmp = jlist.161->list;
        goto <D.26690>;
        <D.26689>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.31916 = ji->ji;
          D.31917 = D.31916->code_start;
          if (D.31917 <= ip) goto <D.31918>; else goto <D.31919>;
          <D.31918>:
          D.31916 = ji->ji;
          D.31917 = D.31916->code_start;
          D.31916 = ji->ji;
          D.31920 = D.31916->code_size;
          D.31921 = (sizetype) D.31920;
          D.31922 = D.31917 + D.31921;
          if (D.31922 > ip) goto <D.31923>; else goto <D.31924>;
          <D.31923>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.31924>:
          <D.31919>:
        }
        tmp = tmp->next;
        <D.26690>:
        if (tmp != 0B) goto <D.26689>; else goto <D.26691>;
        <D.26691>:
        tmp = remove;
        goto <D.26693>;
        <D.26692>:
        jlist.161 = jlist;
        jlist.161 = jlist;
        D.31925 = jlist.161->list;
        D.31926 = tmp->data;
        D.31927 = monoeg_g_slist_delete_link (D.31925, D.31926);
        jlist.161->list = D.31927;
        tmp = tmp->next;
        <D.26693>:
        if (tmp != 0B) goto <D.26692>; else goto <D.26694>;
        <D.26694>:
        monoeg_g_slist_free (remove);
      }
      <D.26696>:
      D.31928 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.31928 != 0) goto <D.26695>; else goto <D.26697>;
      <D.26697>:
      {
        int ret;

        D.31885 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31885);
        if (ret != 0) goto <D.31929>; else goto <D.31930>;
        <D.31929>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31930>:
        D.31931 = ret != 0;
        D.31932 = (long int) D.31931;
        D.31933 = __builtin_expect (D.31932, 0);
        if (D.31933 != 0) goto <D.31934>; else goto <D.31935>;
        <D.31934>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.31935>:
      }
      D.31916 = ji->ji;
      mono_jit_info_table_remove (domain, D.31916);
      if (destroy != 0) goto <D.31936>; else goto <D.31937>;
      <D.31936>:
      D.31938 = ji->code_mp;
      mono_code_manager_destroy (D.31938);
      <D.31937>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.31944;
  struct MonoLMF * D.31947;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.31942>; else goto <D.31943>;
  <D.31942>:
  D.31944 = mono_thread_internal_current ();
  if (D.31944 == thread) goto <D.31945>; else goto <D.31946>;
  <D.31945>:
  mono_set_jit_tls (0B);
  <D.31946>:
  D.31947 = mono_get_lmf ();
  if (D.31947 != 0B) goto <D.31948>; else goto <D.31949>;
  <D.31948>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.31949>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.31943>:
}


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

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


mini_get_imt_trampoline (int slot_index)
{
  void * D.31951;
  int D.31952;

  D.31952 = slot_index + -19;
  D.31951 = mini_get_vtable_trampoline (D.31952);
  return D.31951;
}


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

  D.31954 = MEM[(void * *)descr];
  return D.31954;
}


mini_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  struct GHashTable * D.31956;
  void * D.31959;
  void * * D.31960;
  void * * D.31961;
  void * * desc;

  desc = 0B;
  D.31956 = domain->ftnptrs_hash;
  desc = monoeg_g_hash_table_lookup (D.31956, addr);
  if (desc != 0B) goto <D.31957>; else goto <D.31958>;
  <D.31957>:
  D.31959 = desc;
  return D.31959;
  <D.31958>:
  desc = mono_domain_alloc0 (domain, 24);
  *desc = addr;
  D.31960 = desc + 8;
  *D.31960 = 0B;
  D.31961 = desc + 16;
  *D.31961 = 0B;
  D.31956 = domain->ftnptrs_hash;
  monoeg_g_hash_table_insert_replace (D.31956, addr, desc, 0);
  D.31959 = desc;
  return D.31959;
}


mini_parse_debug_options ()
{
  int D.26819;
  int iftmp.162;
  int D.26818;
  const char[14] * D.31968;
  unsigned char D.31969;
  int D.31970;
  unsigned char D.31971;
  int D.31972;
  const unsigned char * D.31977;
  unsigned char D.31978;
  int D.31979;
  const unsigned char * D.31980;
  unsigned char D.31981;
  int D.31982;
  const unsigned char * D.31987;
  unsigned char D.31988;
  int D.31989;
  const unsigned char * D.31990;
  unsigned char D.31991;
  int D.31992;
  const unsigned char * D.31997;
  unsigned char D.31998;
  int D.31999;
  const unsigned char * D.32000;
  unsigned char D.32001;
  int D.32002;
  int D.26828;
  int iftmp.163;
  int D.26827;
  const char[15] * D.32010;
  unsigned char D.32011;
  int D.32012;
  unsigned char D.32013;
  int D.32014;
  const unsigned char * D.32019;
  unsigned char D.32020;
  int D.32021;
  const unsigned char * D.32022;
  unsigned char D.32023;
  int D.32024;
  const unsigned char * D.32029;
  unsigned char D.32030;
  int D.32031;
  const unsigned char * D.32032;
  unsigned char D.32033;
  int D.32034;
  const unsigned char * D.32039;
  unsigned char D.32040;
  int D.32041;
  const unsigned char * D.32042;
  unsigned char D.32043;
  int D.32044;
  int D.26837;
  int iftmp.164;
  int D.26836;
  const char[27] * D.32052;
  unsigned char D.32053;
  int D.32054;
  unsigned char D.32055;
  int D.32056;
  const unsigned char * D.32061;
  unsigned char D.32062;
  int D.32063;
  const unsigned char * D.32064;
  unsigned char D.32065;
  int D.32066;
  const unsigned char * D.32071;
  unsigned char D.32072;
  int D.32073;
  const unsigned char * D.32074;
  unsigned char D.32075;
  int D.32076;
  const unsigned char * D.32081;
  unsigned char D.32082;
  int D.32083;
  const unsigned char * D.32084;
  unsigned char D.32085;
  int D.32086;
  int D.26846;
  int iftmp.165;
  int D.26845;
  const char[24] * D.32094;
  unsigned char D.32095;
  int D.32096;
  unsigned char D.32097;
  int D.32098;
  const unsigned char * D.32103;
  unsigned char D.32104;
  int D.32105;
  const unsigned char * D.32106;
  unsigned char D.32107;
  int D.32108;
  const unsigned char * D.32113;
  unsigned char D.32114;
  int D.32115;
  const unsigned char * D.32116;
  unsigned char D.32117;
  int D.32118;
  const unsigned char * D.32123;
  unsigned char D.32124;
  int D.32125;
  const unsigned char * D.32126;
  unsigned char D.32127;
  int D.32128;
  int D.26855;
  int iftmp.166;
  int D.26854;
  const char[20] * D.32136;
  unsigned char D.32137;
  int D.32138;
  unsigned char D.32139;
  int D.32140;
  const unsigned char * D.32145;
  unsigned char D.32146;
  int D.32147;
  const unsigned char * D.32148;
  unsigned char D.32149;
  int D.32150;
  const unsigned char * D.32155;
  unsigned char D.32156;
  int D.32157;
  const unsigned char * D.32158;
  unsigned char D.32159;
  int D.32160;
  const unsigned char * D.32165;
  unsigned char D.32166;
  int D.32167;
  const unsigned char * D.32168;
  unsigned char D.32169;
  int D.32170;
  int D.26864;
  int iftmp.167;
  int D.26863;
  const char[17] * D.32178;
  unsigned char D.32179;
  int D.32180;
  unsigned char D.32181;
  int D.32182;
  const unsigned char * D.32187;
  unsigned char D.32188;
  int D.32189;
  const unsigned char * D.32190;
  unsigned char D.32191;
  int D.32192;
  const unsigned char * D.32197;
  unsigned char D.32198;
  int D.32199;
  const unsigned char * D.32200;
  unsigned char D.32201;
  int D.32202;
  const unsigned char * D.32207;
  unsigned char D.32208;
  int D.32209;
  const unsigned char * D.32210;
  unsigned char D.32211;
  int D.32212;
  int D.26873;
  int iftmp.168;
  int D.26872;
  const char[19] * D.32220;
  unsigned char D.32221;
  int D.32222;
  unsigned char D.32223;
  int D.32224;
  const unsigned char * D.32229;
  unsigned char D.32230;
  int D.32231;
  const unsigned char * D.32232;
  unsigned char D.32233;
  int D.32234;
  const unsigned char * D.32239;
  unsigned char D.32240;
  int D.32241;
  const unsigned char * D.32242;
  unsigned char D.32243;
  int D.32244;
  const unsigned char * D.32249;
  unsigned char D.32250;
  int D.32251;
  const unsigned char * D.32252;
  unsigned char D.32253;
  int D.32254;
  int D.26882;
  int iftmp.169;
  int D.26881;
  const char[21] * D.32262;
  unsigned char D.32263;
  int D.32264;
  unsigned char D.32265;
  int D.32266;
  const unsigned char * D.32271;
  unsigned char D.32272;
  int D.32273;
  const unsigned char * D.32274;
  unsigned char D.32275;
  int D.32276;
  const unsigned char * D.32281;
  unsigned char D.32282;
  int D.32283;
  const unsigned char * D.32284;
  unsigned char D.32285;
  int D.32286;
  const unsigned char * D.32291;
  unsigned char D.32292;
  int D.32293;
  const unsigned char * D.32294;
  unsigned char D.32295;
  int D.32296;
  int D.26891;
  int iftmp.170;
  int D.26890;
  const char[18] * D.32304;
  unsigned char D.32305;
  int D.32306;
  unsigned char D.32307;
  int D.32308;
  const unsigned char * D.32313;
  unsigned char D.32314;
  int D.32315;
  const unsigned char * D.32316;
  unsigned char D.32317;
  int D.32318;
  const unsigned char * D.32323;
  unsigned char D.32324;
  int D.32325;
  const unsigned char * D.32326;
  unsigned char D.32327;
  int D.32328;
  const unsigned char * D.32333;
  unsigned char D.32334;
  int D.32335;
  const unsigned char * D.32336;
  unsigned char D.32337;
  int D.32338;
  int D.26900;
  int iftmp.171;
  int D.26899;
  const char[19] * D.32346;
  unsigned char D.32347;
  int D.32348;
  unsigned char D.32349;
  int D.32350;
  const unsigned char * D.32355;
  unsigned char D.32356;
  int D.32357;
  const unsigned char * D.32358;
  unsigned char D.32359;
  int D.32360;
  const unsigned char * D.32365;
  unsigned char D.32366;
  int D.32367;
  const unsigned char * D.32368;
  unsigned char D.32369;
  int D.32370;
  const unsigned char * D.32375;
  unsigned char D.32376;
  int D.32377;
  const unsigned char * D.32378;
  unsigned char D.32379;
  int D.32380;
  int D.26909;
  int iftmp.172;
  int D.26908;
  const char[4] * D.32388;
  unsigned char D.32389;
  int D.32390;
  unsigned char D.32391;
  int D.32392;
  const unsigned char * D.32397;
  unsigned char D.32398;
  int D.32399;
  const unsigned char * D.32400;
  unsigned char D.32401;
  int D.32402;
  const unsigned char * D.32407;
  unsigned char D.32408;
  int D.32409;
  const unsigned char * D.32410;
  unsigned char D.32411;
  int D.32412;
  const unsigned char * D.32417;
  unsigned char D.32418;
  int D.32419;
  const unsigned char * D.32420;
  unsigned char D.32421;
  int D.32422;
  int D.26918;
  int iftmp.173;
  int D.26917;
  const char[21] * D.32430;
  unsigned char D.32431;
  int D.32432;
  unsigned char D.32433;
  int D.32434;
  const unsigned char * D.32439;
  unsigned char D.32440;
  int D.32441;
  const unsigned char * D.32442;
  unsigned char D.32443;
  int D.32444;
  const unsigned char * D.32449;
  unsigned char D.32450;
  int D.32451;
  const unsigned char * D.32452;
  unsigned char D.32453;
  int D.32454;
  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.26927;
  int iftmp.174;
  int D.26926;
  const char[15] * D.32472;
  unsigned char D.32473;
  int D.32474;
  unsigned char D.32475;
  int D.32476;
  const unsigned char * D.32481;
  unsigned char D.32482;
  int D.32483;
  const unsigned char * D.32484;
  unsigned char D.32485;
  int D.32486;
  const unsigned char * D.32491;
  unsigned char D.32492;
  int D.32493;
  const unsigned char * D.32494;
  unsigned char D.32495;
  int D.32496;
  const unsigned char * D.32501;
  unsigned char D.32502;
  int D.32503;
  const unsigned char * D.32504;
  unsigned char D.32505;
  int D.32506;
  int D.26936;
  int iftmp.175;
  int D.26935;
  const char[12] * D.32514;
  unsigned char D.32515;
  int D.32516;
  unsigned char D.32517;
  int D.32518;
  const unsigned char * D.32523;
  unsigned char D.32524;
  int D.32525;
  const unsigned char * D.32526;
  unsigned char D.32527;
  int D.32528;
  const unsigned char * D.32533;
  unsigned char D.32534;
  int D.32535;
  const unsigned char * D.32536;
  unsigned char D.32537;
  int D.32538;
  const unsigned char * D.32543;
  unsigned char D.32544;
  int D.32545;
  const unsigned char * D.32546;
  unsigned char D.32547;
  int D.32548;
  int D.26945;
  int iftmp.176;
  int D.26944;
  const char[6] * D.32556;
  unsigned char D.32557;
  int D.32558;
  unsigned char D.32559;
  int D.32560;
  const unsigned char * D.32565;
  unsigned char D.32566;
  int D.32567;
  const unsigned char * D.32568;
  unsigned char D.32569;
  int D.32570;
  const unsigned char * D.32575;
  unsigned char D.32576;
  int D.32577;
  const unsigned char * D.32578;
  unsigned char D.32579;
  int D.32580;
  const unsigned char * D.32585;
  unsigned char D.32586;
  int D.32587;
  const unsigned char * D.32588;
  unsigned char D.32589;
  int D.32590;
  int D.26954;
  int iftmp.177;
  int D.26953;
  const char[17] * D.32598;
  unsigned char D.32599;
  int D.32600;
  unsigned char D.32601;
  int D.32602;
  const unsigned char * D.32607;
  unsigned char D.32608;
  int D.32609;
  const unsigned char * D.32610;
  unsigned char D.32611;
  int D.32612;
  const unsigned char * D.32617;
  unsigned char D.32618;
  int D.32619;
  const unsigned char * D.32620;
  unsigned char D.32621;
  int D.32622;
  const unsigned char * D.32627;
  unsigned char D.32628;
  int D.32629;
  const unsigned char * D.32630;
  unsigned char D.32631;
  int D.32632;
  struct _IO_FILE * stderr.178;
  gchar * D.32639;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.31963>; else goto <D.31964>;
  <D.31963>:
  return;
  <D.31964>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.26956>;
  <D.26955>:
  {
    const char * arg;

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

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

        __s2 = arg;
        D.31968 = "handle-sigint";
        D.31969 = MEM[(const unsigned char *)D.31968];
        D.31970 = (int) D.31969;
        D.31971 = *__s2;
        D.31972 = (int) D.31971;
        __result = D.31970 - D.31972;
        {
          if (__s2_len != 0) goto <D.31973>; else goto <D.31974>;
          <D.31973>:
          if (__result == 0) goto <D.31975>; else goto <D.31976>;
          <D.31975>:
          D.31977 = &MEM[(void *)"handle-sigint" + 1B];
          D.31978 = *D.31977;
          D.31979 = (int) D.31978;
          D.31980 = __s2 + 1;
          D.31981 = *D.31980;
          D.31982 = (int) D.31981;
          __result = D.31979 - D.31982;
          if (__s2_len > 1) goto <D.31983>; else goto <D.31984>;
          <D.31983>:
          if (__result == 0) goto <D.31985>; else goto <D.31986>;
          <D.31985>:
          D.31987 = &MEM[(void *)"handle-sigint" + 2B];
          D.31988 = *D.31987;
          D.31989 = (int) D.31988;
          D.31990 = __s2 + 2;
          D.31991 = *D.31990;
          D.31992 = (int) D.31991;
          __result = D.31989 - D.31992;
          if (__s2_len > 2) goto <D.31993>; else goto <D.31994>;
          <D.31993>:
          if (__result == 0) goto <D.31995>; else goto <D.31996>;
          <D.31995>:
          D.31997 = &MEM[(void *)"handle-sigint" + 3B];
          D.31998 = *D.31997;
          D.31999 = (int) D.31998;
          D.32000 = __s2 + 3;
          D.32001 = *D.32000;
          D.32002 = (int) D.32001;
          __result = D.31999 - D.32002;
          <D.31996>:
          <D.31994>:
          <D.31986>:
          <D.31984>:
          <D.31976>:
          <D.31974>:
        }
        D.26818 = __result;
      }
      iftmp.162 = -D.26818;
      goto <D.32003>;
      <D.31967>:
      iftmp.162 = __builtin_strcmp (arg, "handle-sigint");
      <D.32003>:
      D.26819 = iftmp.162;
    }
    if (D.26819 == 0) goto <D.32004>; else goto <D.32005>;
    <D.32004>:
    debug_options.handle_sigint = 1;
    goto <D.32006>;
    <D.32005>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32010 = "keep-delegates";
        D.32011 = MEM[(const unsigned char *)D.32010];
        D.32012 = (int) D.32011;
        D.32013 = *__s2;
        D.32014 = (int) D.32013;
        __result = D.32012 - D.32014;
        {
          if (__s2_len != 0) goto <D.32015>; else goto <D.32016>;
          <D.32015>:
          if (__result == 0) goto <D.32017>; else goto <D.32018>;
          <D.32017>:
          D.32019 = &MEM[(void *)"keep-delegates" + 1B];
          D.32020 = *D.32019;
          D.32021 = (int) D.32020;
          D.32022 = __s2 + 1;
          D.32023 = *D.32022;
          D.32024 = (int) D.32023;
          __result = D.32021 - D.32024;
          if (__s2_len > 1) goto <D.32025>; else goto <D.32026>;
          <D.32025>:
          if (__result == 0) goto <D.32027>; else goto <D.32028>;
          <D.32027>:
          D.32029 = &MEM[(void *)"keep-delegates" + 2B];
          D.32030 = *D.32029;
          D.32031 = (int) D.32030;
          D.32032 = __s2 + 2;
          D.32033 = *D.32032;
          D.32034 = (int) D.32033;
          __result = D.32031 - D.32034;
          if (__s2_len > 2) goto <D.32035>; else goto <D.32036>;
          <D.32035>:
          if (__result == 0) goto <D.32037>; else goto <D.32038>;
          <D.32037>:
          D.32039 = &MEM[(void *)"keep-delegates" + 3B];
          D.32040 = *D.32039;
          D.32041 = (int) D.32040;
          D.32042 = __s2 + 3;
          D.32043 = *D.32042;
          D.32044 = (int) D.32043;
          __result = D.32041 - D.32044;
          <D.32038>:
          <D.32036>:
          <D.32028>:
          <D.32026>:
          <D.32018>:
          <D.32016>:
        }
        D.26827 = __result;
      }
      iftmp.163 = -D.26827;
      goto <D.32045>;
      <D.32009>:
      iftmp.163 = __builtin_strcmp (arg, "keep-delegates");
      <D.32045>:
      D.26828 = iftmp.163;
    }
    if (D.26828 == 0) goto <D.32046>; else goto <D.32047>;
    <D.32046>:
    debug_options.keep_delegates = 1;
    goto <D.32048>;
    <D.32047>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32052 = "reverse-pinvoke-exceptions";
        D.32053 = MEM[(const unsigned char *)D.32052];
        D.32054 = (int) D.32053;
        D.32055 = *__s2;
        D.32056 = (int) D.32055;
        __result = D.32054 - D.32056;
        {
          if (__s2_len != 0) goto <D.32057>; else goto <D.32058>;
          <D.32057>:
          if (__result == 0) goto <D.32059>; else goto <D.32060>;
          <D.32059>:
          D.32061 = &MEM[(void *)"reverse-pinvoke-exceptions" + 1B];
          D.32062 = *D.32061;
          D.32063 = (int) D.32062;
          D.32064 = __s2 + 1;
          D.32065 = *D.32064;
          D.32066 = (int) D.32065;
          __result = D.32063 - D.32066;
          if (__s2_len > 1) goto <D.32067>; else goto <D.32068>;
          <D.32067>:
          if (__result == 0) goto <D.32069>; else goto <D.32070>;
          <D.32069>:
          D.32071 = &MEM[(void *)"reverse-pinvoke-exceptions" + 2B];
          D.32072 = *D.32071;
          D.32073 = (int) D.32072;
          D.32074 = __s2 + 2;
          D.32075 = *D.32074;
          D.32076 = (int) D.32075;
          __result = D.32073 - D.32076;
          if (__s2_len > 2) goto <D.32077>; else goto <D.32078>;
          <D.32077>:
          if (__result == 0) goto <D.32079>; else goto <D.32080>;
          <D.32079>:
          D.32081 = &MEM[(void *)"reverse-pinvoke-exceptions" + 3B];
          D.32082 = *D.32081;
          D.32083 = (int) D.32082;
          D.32084 = __s2 + 3;
          D.32085 = *D.32084;
          D.32086 = (int) D.32085;
          __result = D.32083 - D.32086;
          <D.32080>:
          <D.32078>:
          <D.32070>:
          <D.32068>:
          <D.32060>:
          <D.32058>:
        }
        D.26836 = __result;
      }
      iftmp.164 = -D.26836;
      goto <D.32087>;
      <D.32051>:
      iftmp.164 = __builtin_strcmp (arg, "reverse-pinvoke-exceptions");
      <D.32087>:
      D.26837 = iftmp.164;
    }
    if (D.26837 == 0) goto <D.32088>; else goto <D.32089>;
    <D.32088>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.32090>;
    <D.32089>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32094 = "collect-pagefault-stats";
        D.32095 = MEM[(const unsigned char *)D.32094];
        D.32096 = (int) D.32095;
        D.32097 = *__s2;
        D.32098 = (int) D.32097;
        __result = D.32096 - D.32098;
        {
          if (__s2_len != 0) goto <D.32099>; else goto <D.32100>;
          <D.32099>:
          if (__result == 0) goto <D.32101>; else goto <D.32102>;
          <D.32101>:
          D.32103 = &MEM[(void *)"collect-pagefault-stats" + 1B];
          D.32104 = *D.32103;
          D.32105 = (int) D.32104;
          D.32106 = __s2 + 1;
          D.32107 = *D.32106;
          D.32108 = (int) D.32107;
          __result = D.32105 - D.32108;
          if (__s2_len > 1) goto <D.32109>; else goto <D.32110>;
          <D.32109>:
          if (__result == 0) goto <D.32111>; else goto <D.32112>;
          <D.32111>:
          D.32113 = &MEM[(void *)"collect-pagefault-stats" + 2B];
          D.32114 = *D.32113;
          D.32115 = (int) D.32114;
          D.32116 = __s2 + 2;
          D.32117 = *D.32116;
          D.32118 = (int) D.32117;
          __result = D.32115 - D.32118;
          if (__s2_len > 2) goto <D.32119>; else goto <D.32120>;
          <D.32119>:
          if (__result == 0) goto <D.32121>; else goto <D.32122>;
          <D.32121>:
          D.32123 = &MEM[(void *)"collect-pagefault-stats" + 3B];
          D.32124 = *D.32123;
          D.32125 = (int) D.32124;
          D.32126 = __s2 + 3;
          D.32127 = *D.32126;
          D.32128 = (int) D.32127;
          __result = D.32125 - D.32128;
          <D.32122>:
          <D.32120>:
          <D.32112>:
          <D.32110>:
          <D.32102>:
          <D.32100>:
        }
        D.26845 = __result;
      }
      iftmp.165 = -D.26845;
      goto <D.32129>;
      <D.32093>:
      iftmp.165 = __builtin_strcmp (arg, "collect-pagefault-stats");
      <D.32129>:
      D.26846 = iftmp.165;
    }
    if (D.26846 == 0) goto <D.32130>; else goto <D.32131>;
    <D.32130>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.32132>;
    <D.32131>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32136 = "break-on-unverified";
        D.32137 = MEM[(const unsigned char *)D.32136];
        D.32138 = (int) D.32137;
        D.32139 = *__s2;
        D.32140 = (int) D.32139;
        __result = D.32138 - D.32140;
        {
          if (__s2_len != 0) goto <D.32141>; else goto <D.32142>;
          <D.32141>:
          if (__result == 0) goto <D.32143>; else goto <D.32144>;
          <D.32143>:
          D.32145 = &MEM[(void *)"break-on-unverified" + 1B];
          D.32146 = *D.32145;
          D.32147 = (int) D.32146;
          D.32148 = __s2 + 1;
          D.32149 = *D.32148;
          D.32150 = (int) D.32149;
          __result = D.32147 - D.32150;
          if (__s2_len > 1) goto <D.32151>; else goto <D.32152>;
          <D.32151>:
          if (__result == 0) goto <D.32153>; else goto <D.32154>;
          <D.32153>:
          D.32155 = &MEM[(void *)"break-on-unverified" + 2B];
          D.32156 = *D.32155;
          D.32157 = (int) D.32156;
          D.32158 = __s2 + 2;
          D.32159 = *D.32158;
          D.32160 = (int) D.32159;
          __result = D.32157 - D.32160;
          if (__s2_len > 2) goto <D.32161>; else goto <D.32162>;
          <D.32161>:
          if (__result == 0) goto <D.32163>; else goto <D.32164>;
          <D.32163>:
          D.32165 = &MEM[(void *)"break-on-unverified" + 3B];
          D.32166 = *D.32165;
          D.32167 = (int) D.32166;
          D.32168 = __s2 + 3;
          D.32169 = *D.32168;
          D.32170 = (int) D.32169;
          __result = D.32167 - D.32170;
          <D.32164>:
          <D.32162>:
          <D.32154>:
          <D.32152>:
          <D.32144>:
          <D.32142>:
        }
        D.26854 = __result;
      }
      iftmp.166 = -D.26854;
      goto <D.32171>;
      <D.32135>:
      iftmp.166 = __builtin_strcmp (arg, "break-on-unverified");
      <D.32171>:
      D.26855 = iftmp.166;
    }
    if (D.26855 == 0) goto <D.32172>; else goto <D.32173>;
    <D.32172>:
    debug_options.break_on_unverified = 1;
    goto <D.32174>;
    <D.32173>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32178 = "no-gdb-backtrace";
        D.32179 = MEM[(const unsigned char *)D.32178];
        D.32180 = (int) D.32179;
        D.32181 = *__s2;
        D.32182 = (int) D.32181;
        __result = D.32180 - D.32182;
        {
          if (__s2_len != 0) goto <D.32183>; else goto <D.32184>;
          <D.32183>:
          if (__result == 0) goto <D.32185>; else goto <D.32186>;
          <D.32185>:
          D.32187 = &MEM[(void *)"no-gdb-backtrace" + 1B];
          D.32188 = *D.32187;
          D.32189 = (int) D.32188;
          D.32190 = __s2 + 1;
          D.32191 = *D.32190;
          D.32192 = (int) D.32191;
          __result = D.32189 - D.32192;
          if (__s2_len > 1) goto <D.32193>; else goto <D.32194>;
          <D.32193>:
          if (__result == 0) goto <D.32195>; else goto <D.32196>;
          <D.32195>:
          D.32197 = &MEM[(void *)"no-gdb-backtrace" + 2B];
          D.32198 = *D.32197;
          D.32199 = (int) D.32198;
          D.32200 = __s2 + 2;
          D.32201 = *D.32200;
          D.32202 = (int) D.32201;
          __result = D.32199 - D.32202;
          if (__s2_len > 2) goto <D.32203>; else goto <D.32204>;
          <D.32203>:
          if (__result == 0) goto <D.32205>; else goto <D.32206>;
          <D.32205>:
          D.32207 = &MEM[(void *)"no-gdb-backtrace" + 3B];
          D.32208 = *D.32207;
          D.32209 = (int) D.32208;
          D.32210 = __s2 + 3;
          D.32211 = *D.32210;
          D.32212 = (int) D.32211;
          __result = D.32209 - D.32212;
          <D.32206>:
          <D.32204>:
          <D.32196>:
          <D.32194>:
          <D.32186>:
          <D.32184>:
        }
        D.26863 = __result;
      }
      iftmp.167 = -D.26863;
      goto <D.32213>;
      <D.32177>:
      iftmp.167 = __builtin_strcmp (arg, "no-gdb-backtrace");
      <D.32213>:
      D.26864 = iftmp.167;
    }
    if (D.26864 == 0) goto <D.32214>; else goto <D.32215>;
    <D.32214>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.32216>;
    <D.32215>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32220 = "suspend-on-sigsegv";
        D.32221 = MEM[(const unsigned char *)D.32220];
        D.32222 = (int) D.32221;
        D.32223 = *__s2;
        D.32224 = (int) D.32223;
        __result = D.32222 - D.32224;
        {
          if (__s2_len != 0) goto <D.32225>; else goto <D.32226>;
          <D.32225>:
          if (__result == 0) goto <D.32227>; else goto <D.32228>;
          <D.32227>:
          D.32229 = &MEM[(void *)"suspend-on-sigsegv" + 1B];
          D.32230 = *D.32229;
          D.32231 = (int) D.32230;
          D.32232 = __s2 + 1;
          D.32233 = *D.32232;
          D.32234 = (int) D.32233;
          __result = D.32231 - D.32234;
          if (__s2_len > 1) goto <D.32235>; else goto <D.32236>;
          <D.32235>:
          if (__result == 0) goto <D.32237>; else goto <D.32238>;
          <D.32237>:
          D.32239 = &MEM[(void *)"suspend-on-sigsegv" + 2B];
          D.32240 = *D.32239;
          D.32241 = (int) D.32240;
          D.32242 = __s2 + 2;
          D.32243 = *D.32242;
          D.32244 = (int) D.32243;
          __result = D.32241 - D.32244;
          if (__s2_len > 2) goto <D.32245>; else goto <D.32246>;
          <D.32245>:
          if (__result == 0) goto <D.32247>; else goto <D.32248>;
          <D.32247>:
          D.32249 = &MEM[(void *)"suspend-on-sigsegv" + 3B];
          D.32250 = *D.32249;
          D.32251 = (int) D.32250;
          D.32252 = __s2 + 3;
          D.32253 = *D.32252;
          D.32254 = (int) D.32253;
          __result = D.32251 - D.32254;
          <D.32248>:
          <D.32246>:
          <D.32238>:
          <D.32236>:
          <D.32228>:
          <D.32226>:
        }
        D.26872 = __result;
      }
      iftmp.168 = -D.26872;
      goto <D.32255>;
      <D.32219>:
      iftmp.168 = __builtin_strcmp (arg, "suspend-on-sigsegv");
      <D.32255>:
      D.26873 = iftmp.168;
    }
    if (D.26873 == 0) goto <D.32256>; else goto <D.32257>;
    <D.32256>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.32258>;
    <D.32257>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32262 = "suspend-on-unhandled";
        D.32263 = MEM[(const unsigned char *)D.32262];
        D.32264 = (int) D.32263;
        D.32265 = *__s2;
        D.32266 = (int) D.32265;
        __result = D.32264 - D.32266;
        {
          if (__s2_len != 0) goto <D.32267>; else goto <D.32268>;
          <D.32267>:
          if (__result == 0) goto <D.32269>; else goto <D.32270>;
          <D.32269>:
          D.32271 = &MEM[(void *)"suspend-on-unhandled" + 1B];
          D.32272 = *D.32271;
          D.32273 = (int) D.32272;
          D.32274 = __s2 + 1;
          D.32275 = *D.32274;
          D.32276 = (int) D.32275;
          __result = D.32273 - D.32276;
          if (__s2_len > 1) goto <D.32277>; else goto <D.32278>;
          <D.32277>:
          if (__result == 0) goto <D.32279>; else goto <D.32280>;
          <D.32279>:
          D.32281 = &MEM[(void *)"suspend-on-unhandled" + 2B];
          D.32282 = *D.32281;
          D.32283 = (int) D.32282;
          D.32284 = __s2 + 2;
          D.32285 = *D.32284;
          D.32286 = (int) D.32285;
          __result = D.32283 - D.32286;
          if (__s2_len > 2) goto <D.32287>; else goto <D.32288>;
          <D.32287>:
          if (__result == 0) goto <D.32289>; else goto <D.32290>;
          <D.32289>:
          D.32291 = &MEM[(void *)"suspend-on-unhandled" + 3B];
          D.32292 = *D.32291;
          D.32293 = (int) D.32292;
          D.32294 = __s2 + 3;
          D.32295 = *D.32294;
          D.32296 = (int) D.32295;
          __result = D.32293 - D.32296;
          <D.32290>:
          <D.32288>:
          <D.32280>:
          <D.32278>:
          <D.32270>:
          <D.32268>:
        }
        D.26881 = __result;
      }
      iftmp.169 = -D.26881;
      goto <D.32297>;
      <D.32261>:
      iftmp.169 = __builtin_strcmp (arg, "suspend-on-unhandled");
      <D.32297>:
      D.26882 = iftmp.169;
    }
    if (D.26882 == 0) goto <D.32298>; else goto <D.32299>;
    <D.32298>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.32300>;
    <D.32299>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32304 = "dont-free-domains";
        D.32305 = MEM[(const unsigned char *)D.32304];
        D.32306 = (int) D.32305;
        D.32307 = *__s2;
        D.32308 = (int) D.32307;
        __result = D.32306 - D.32308;
        {
          if (__s2_len != 0) goto <D.32309>; else goto <D.32310>;
          <D.32309>:
          if (__result == 0) goto <D.32311>; else goto <D.32312>;
          <D.32311>:
          D.32313 = &MEM[(void *)"dont-free-domains" + 1B];
          D.32314 = *D.32313;
          D.32315 = (int) D.32314;
          D.32316 = __s2 + 1;
          D.32317 = *D.32316;
          D.32318 = (int) D.32317;
          __result = D.32315 - D.32318;
          if (__s2_len > 1) goto <D.32319>; else goto <D.32320>;
          <D.32319>:
          if (__result == 0) goto <D.32321>; else goto <D.32322>;
          <D.32321>:
          D.32323 = &MEM[(void *)"dont-free-domains" + 2B];
          D.32324 = *D.32323;
          D.32325 = (int) D.32324;
          D.32326 = __s2 + 2;
          D.32327 = *D.32326;
          D.32328 = (int) D.32327;
          __result = D.32325 - D.32328;
          if (__s2_len > 2) goto <D.32329>; else goto <D.32330>;
          <D.32329>:
          if (__result == 0) goto <D.32331>; else goto <D.32332>;
          <D.32331>:
          D.32333 = &MEM[(void *)"dont-free-domains" + 3B];
          D.32334 = *D.32333;
          D.32335 = (int) D.32334;
          D.32336 = __s2 + 3;
          D.32337 = *D.32336;
          D.32338 = (int) D.32337;
          __result = D.32335 - D.32338;
          <D.32332>:
          <D.32330>:
          <D.32322>:
          <D.32320>:
          <D.32312>:
          <D.32310>:
        }
        D.26890 = __result;
      }
      iftmp.170 = -D.26890;
      goto <D.32339>;
      <D.32303>:
      iftmp.170 = __builtin_strcmp (arg, "dont-free-domains");
      <D.32339>:
      D.26891 = iftmp.170;
    }
    if (D.26891 == 0) goto <D.32340>; else goto <D.32341>;
    <D.32340>:
    mono_dont_free_domains = 1;
    goto <D.32342>;
    <D.32341>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

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

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

        __s2 = arg;
        D.32430 = "explicit-null-checks";
        D.32431 = MEM[(const unsigned char *)D.32430];
        D.32432 = (int) D.32431;
        D.32433 = *__s2;
        D.32434 = (int) D.32433;
        __result = D.32432 - D.32434;
        {
          if (__s2_len != 0) goto <D.32435>; else goto <D.32436>;
          <D.32435>:
          if (__result == 0) goto <D.32437>; else goto <D.32438>;
          <D.32437>:
          D.32439 = &MEM[(void *)"explicit-null-checks" + 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;
          if (__s2_len > 1) goto <D.32445>; else goto <D.32446>;
          <D.32445>:
          if (__result == 0) goto <D.32447>; else goto <D.32448>;
          <D.32447>:
          D.32449 = &MEM[(void *)"explicit-null-checks" + 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;
          if (__s2_len > 2) goto <D.32455>; else goto <D.32456>;
          <D.32455>:
          if (__result == 0) goto <D.32457>; else goto <D.32458>;
          <D.32457>:
          D.32459 = &MEM[(void *)"explicit-null-checks" + 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.32456>:
          <D.32448>:
          <D.32446>:
          <D.32438>:
          <D.32436>:
        }
        D.26917 = __result;
      }
      iftmp.173 = -D.26917;
      goto <D.32465>;
      <D.32429>:
      iftmp.173 = __builtin_strcmp (arg, "explicit-null-checks");
      <D.32465>:
      D.26918 = iftmp.173;
    }
    if (D.26918 == 0) goto <D.32466>; else goto <D.32467>;
    <D.32466>:
    debug_options.explicit_null_checks = 1;
    goto <D.32468>;
    <D.32467>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.32472 = "gen-seq-points";
        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;
        {
          if (__s2_len != 0) goto <D.32477>; else goto <D.32478>;
          <D.32477>:
          if (__result == 0) goto <D.32479>; else goto <D.32480>;
          <D.32479>:
          D.32481 = &MEM[(void *)"gen-seq-points" + 1B];
          D.32482 = *D.32481;
          D.32483 = (int) D.32482;
          D.32484 = __s2 + 1;
          D.32485 = *D.32484;
          D.32486 = (int) D.32485;
          __result = D.32483 - D.32486;
          if (__s2_len > 1) goto <D.32487>; else goto <D.32488>;
          <D.32487>:
          if (__result == 0) goto <D.32489>; else goto <D.32490>;
          <D.32489>:
          D.32491 = &MEM[(void *)"gen-seq-points" + 2B];
          D.32492 = *D.32491;
          D.32493 = (int) D.32492;
          D.32494 = __s2 + 2;
          D.32495 = *D.32494;
          D.32496 = (int) D.32495;
          __result = D.32493 - D.32496;
          if (__s2_len > 2) goto <D.32497>; else goto <D.32498>;
          <D.32497>:
          if (__result == 0) goto <D.32499>; else goto <D.32500>;
          <D.32499>:
          D.32501 = &MEM[(void *)"gen-seq-points" + 3B];
          D.32502 = *D.32501;
          D.32503 = (int) D.32502;
          D.32504 = __s2 + 3;
          D.32505 = *D.32504;
          D.32506 = (int) D.32505;
          __result = D.32503 - D.32506;
          <D.32500>:
          <D.32498>:
          <D.32490>:
          <D.32488>:
          <D.32480>:
          <D.32478>:
        }
        D.26926 = __result;
      }
      iftmp.174 = -D.26926;
      goto <D.32507>;
      <D.32471>:
      iftmp.174 = __builtin_strcmp (arg, "gen-seq-points");
      <D.32507>:
      D.26927 = iftmp.174;
    }
    if (D.26927 == 0) goto <D.32508>; else goto <D.32509>;
    <D.32508>:
    debug_options.gen_seq_points = 1;
    goto <D.32510>;
    <D.32509>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

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

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

        __s2 = arg;
        D.32598 = "soft-breakpoints";
        D.32599 = MEM[(const unsigned char *)D.32598];
        D.32600 = (int) D.32599;
        D.32601 = *__s2;
        D.32602 = (int) D.32601;
        __result = D.32600 - D.32602;
        {
          if (__s2_len != 0) goto <D.32603>; else goto <D.32604>;
          <D.32603>:
          if (__result == 0) goto <D.32605>; else goto <D.32606>;
          <D.32605>:
          D.32607 = &MEM[(void *)"soft-breakpoints" + 1B];
          D.32608 = *D.32607;
          D.32609 = (int) D.32608;
          D.32610 = __s2 + 1;
          D.32611 = *D.32610;
          D.32612 = (int) D.32611;
          __result = D.32609 - D.32612;
          if (__s2_len > 1) goto <D.32613>; else goto <D.32614>;
          <D.32613>:
          if (__result == 0) goto <D.32615>; else goto <D.32616>;
          <D.32615>:
          D.32617 = &MEM[(void *)"soft-breakpoints" + 2B];
          D.32618 = *D.32617;
          D.32619 = (int) D.32618;
          D.32620 = __s2 + 2;
          D.32621 = *D.32620;
          D.32622 = (int) D.32621;
          __result = D.32619 - D.32622;
          if (__s2_len > 2) goto <D.32623>; else goto <D.32624>;
          <D.32623>:
          if (__result == 0) goto <D.32625>; else goto <D.32626>;
          <D.32625>:
          D.32627 = &MEM[(void *)"soft-breakpoints" + 3B];
          D.32628 = *D.32627;
          D.32629 = (int) D.32628;
          D.32630 = __s2 + 3;
          D.32631 = *D.32630;
          D.32632 = (int) D.32631;
          __result = D.32629 - D.32632;
          <D.32626>:
          <D.32624>:
          <D.32616>:
          <D.32614>:
          <D.32606>:
          <D.32604>:
        }
        D.26953 = __result;
      }
      iftmp.177 = -D.26953;
      goto <D.32633>;
      <D.32597>:
      iftmp.177 = __builtin_strcmp (arg, "soft-breakpoints");
      <D.32633>:
      D.26954 = iftmp.177;
    }
    if (D.26954 == 0) goto <D.32634>; else goto <D.32635>;
    <D.32634>:
    debug_options.soft_breakpoints = 1;
    goto <D.32636>;
    <D.32635>:
    stderr.178 = stderr;
    fprintf (stderr.178, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.178 = stderr;
    fprintf (stderr.178, "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.32636>:
    <D.32594>:
    <D.32552>:
    <D.32510>:
    <D.32468>:
    <D.32426>:
    <D.32384>:
    <D.32342>:
    <D.32300>:
    <D.32258>:
    <D.32216>:
    <D.32174>:
    <D.32132>:
    <D.32090>:
    <D.32048>:
    <D.32006>:
  }
  ptr = ptr + 8;
  <D.26956>:
  if (ptr != 0B) goto <D.32638>; else goto <D.26957>;
  <D.32638>:
  D.32639 = *ptr;
  if (D.32639 != 0B) goto <D.26955>; else goto <D.26957>;
  <D.26957>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32641;
  void (*<Tbf>) (void *) destructor.179;
  int D.32643;
  _Bool D.32644;

  destructor.179 = (void (*<Tbf>) (void *)) destructor;
  D.32643 = pthread_key_create (key, destructor.179);
  D.32644 = D.32643 == 0;
  D.32641 = (int) D.32644;
  return D.32641;
}


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.32646>; else goto <D.32647>;
  <D.32646>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32648>;
  <D.32647>:
  sig = 0B;
  <D.32648>:
  mono_register_jit_icall (func, name, sig, save);
}


register_opcode_emulation (int opcode, const char * name, const char * sigstr, void * func, const char * symbol, gboolean no_throw)
{
  long unsigned int D.32649;
  long unsigned int D.32650;
  _Bool D.32651;
  long int D.32652;
  long int D.32653;
  short unsigned int D.32656;
  _Bool D.32657;
  long int D.32658;
  long int D.32659;
  short int emul_opcode_num.180;
  short int emul_opcode_alloced.181;
  int iftmp.182;
  short int D.32669;
  unsigned short D.32671;
  unsigned short emul_opcode_alloced.183;
  unsigned short D.32673;
  short int emul_opcode_alloced.184;
  struct MonoJitICallInfo * * emul_opcode_map.185;
  long unsigned int D.32676;
  long unsigned int D.32677;
  void * emul_opcode_map.186;
  short int * emul_opcode_opcodes.187;
  long unsigned int D.32680;
  void * emul_opcode_opcodes.188;
  long unsigned int D.32682;
  long unsigned int D.32683;
  struct MonoJitICallInfo * * D.32684;
  long unsigned int D.32685;
  short int * D.32686;
  short int D.32687;
  short int emul_opcode_num.189;
  unsigned short emul_opcode_num.190;
  unsigned short D.32690;
  short int emul_opcode_num.191;
  int D.32692;
  unsigned char D.32693;
  signed char D.32694;
  int D.32695;
  int D.32696;
  signed char D.32697;
  signed char D.32698;
  unsigned char D.32699;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.32649 = BIT_FIELD_REF <*sig, 64, 64>;
  D.32650 = D.32649 & 18014398509481984;
  D.32651 = D.32650 != 0;
  D.32652 = (long int) D.32651;
  D.32653 = __builtin_expect (D.32652, 0);
  if (D.32653 != 0) goto <D.32654>; else goto <D.32655>;
  <D.32654>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.32655>:
  D.32656 = sig->param_count;
  D.32657 = D.32656 > 2;
  D.32658 = (long int) D.32657;
  D.32659 = __builtin_expect (D.32658, 0);
  if (D.32659 != 0) goto <D.32660>; else goto <D.32661>;
  <D.32660>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.32661>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.180 = emul_opcode_num;
  emul_opcode_alloced.181 = emul_opcode_alloced;
  if (emul_opcode_num.180 >= emul_opcode_alloced.181) goto <D.32664>; else goto <D.32665>;
  <D.32664>:
  {
    int incr;

    emul_opcode_alloced.181 = emul_opcode_alloced;
    if (emul_opcode_alloced.181 != 0) goto <D.32667>; else goto <D.32668>;
    <D.32667>:
    emul_opcode_alloced.181 = emul_opcode_alloced;
    D.32669 = emul_opcode_alloced.181 / 2;
    iftmp.182 = (int) D.32669;
    goto <D.32670>;
    <D.32668>:
    iftmp.182 = 16;
    <D.32670>:
    incr = iftmp.182;
    D.32671 = (unsigned short) incr;
    emul_opcode_alloced.181 = emul_opcode_alloced;
    emul_opcode_alloced.183 = (unsigned short) emul_opcode_alloced.181;
    D.32673 = D.32671 + emul_opcode_alloced.183;
    emul_opcode_alloced.184 = (short int) D.32673;
    emul_opcode_alloced = emul_opcode_alloced.184;
    emul_opcode_map.185 = emul_opcode_map;
    emul_opcode_alloced.181 = emul_opcode_alloced;
    D.32676 = (long unsigned int) emul_opcode_alloced.181;
    D.32677 = D.32676 * 8;
    emul_opcode_map.186 = monoeg_realloc (emul_opcode_map.185, D.32677);
    emul_opcode_map = emul_opcode_map.186;
    emul_opcode_opcodes.187 = emul_opcode_opcodes;
    emul_opcode_alloced.181 = emul_opcode_alloced;
    D.32676 = (long unsigned int) emul_opcode_alloced.181;
    D.32680 = D.32676 * 2;
    emul_opcode_opcodes.188 = monoeg_realloc (emul_opcode_opcodes.187, D.32680);
    emul_opcode_opcodes = emul_opcode_opcodes.188;
  }
  <D.32665>:
  emul_opcode_map.185 = emul_opcode_map;
  emul_opcode_num.180 = emul_opcode_num;
  D.32682 = (long unsigned int) emul_opcode_num.180;
  D.32683 = D.32682 * 8;
  D.32684 = emul_opcode_map.185 + D.32683;
  *D.32684 = info;
  emul_opcode_opcodes.187 = emul_opcode_opcodes;
  emul_opcode_num.180 = emul_opcode_num;
  D.32682 = (long unsigned int) emul_opcode_num.180;
  D.32685 = D.32682 * 2;
  D.32686 = emul_opcode_opcodes.187 + D.32685;
  D.32687 = (short int) opcode;
  *D.32686 = D.32687;
  emul_opcode_num.180 = emul_opcode_num;
  emul_opcode_num.189 = emul_opcode_num.180;
  emul_opcode_num.190 = (unsigned short) emul_opcode_num.189;
  D.32690 = emul_opcode_num.190 + 1;
  emul_opcode_num.191 = (short int) D.32690;
  emul_opcode_num = emul_opcode_num.191;
  D.32692 = opcode >> 6;
  D.32692 = opcode >> 6;
  D.32693 = emul_opcode_hit_cache[D.32692];
  D.32694 = (signed char) D.32693;
  D.32695 = opcode & 7;
  D.32696 = 1 << D.32695;
  D.32697 = (signed char) D.32696;
  D.32698 = D.32694 | D.32697;
  D.32699 = (unsigned char) D.32698;
  emul_opcode_hit_cache[D.32692] = D.32699;
}


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

  if (sigstr != 0B) goto <D.32700>; else goto <D.32701>;
  <D.32700>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.32702>;
  <D.32701>:
  sig = 0B;
  <D.32702>:
  if (save != 0) goto <D.32704>; else goto <D.32705>;
  <D.32704>:
  iftmp.192 = name;
  goto <D.32706>;
  <D.32705>:
  iftmp.192 = 0B;
  <D.32706>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.192);
}


mini_cleanup (struct MonoDomain * domain)
{
  unsigned int mono_jit_tls_id.193;
  void * D.32708;
  int mono_dont_free_global_codeman.194;
  struct MonoCodeManager * global_codeman.195;
  struct GHashTable * jit_icall_name_hash.196;
  struct MonoJitICallInfo * * emul_opcode_map.197;
  short int * emul_opcode_opcodes.198;
  void * * vtable_trampolines.199;
  struct _IO_FILE * stdout.200;
  struct MonoMethodDesc * mono_inject_async_exc_method.201;

  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.193 = mono_jit_tls_id;
  D.32708 = pthread_getspecific (mono_jit_tls_id.193);
  free_jit_tls_data (D.32708);
  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.194 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.194 == 0) goto <D.32710>; else goto <D.32711>;
  <D.32710>:
  global_codeman.195 = global_codeman;
  mono_code_manager_destroy (global_codeman.195);
  <D.32711>:
  jit_icall_name_hash.196 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.196);
  emul_opcode_map.197 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.197);
  emul_opcode_opcodes.198 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.198);
  vtable_trampolines.199 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.199);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.200 = stdout;
  mono_counters_dump (-1, stdout.200);
  mono_inject_async_exc_method.201 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.201 != 0B) goto <D.32719>; else goto <D.32720>;
  <D.32719>:
  mono_inject_async_exc_method.201 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.201);
  <D.32720>:
  mono_jit_tls_id.193 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.193);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.32721;
  int D.32724;
  double D.32725;
  double D.32726;
  char * D.32727;
  int D.32728;
  char * D.32729;
  long unsigned int D.32730;
  long unsigned int D.32731;
  long unsigned int D.32732;
  long unsigned int D.32733;
  long unsigned int D.32734;
  long unsigned int D.32735;
  long unsigned int D.32736;
  struct MonoImage * D.32737;
  struct MonoMemPool * D.32738;
  unsigned int D.32739;
  long unsigned int D.32740;
  long unsigned int D.32741;
  int D.32742;
  long unsigned int D.32743;
  long unsigned int D.32744;
  long unsigned int D.32745;
  long unsigned int D.32746;
  long unsigned int D.32747;
  long unsigned int D.32748;
  long unsigned int D.32749;
  long unsigned int D.32750;
  long unsigned int D.32751;
  long unsigned int D.32752;
  long unsigned int D.32753;
  long unsigned int D.32754;
  long unsigned int D.32755;
  long unsigned int D.32756;
  long unsigned int D.32757;
  long unsigned int D.32758;
  long unsigned int D.32759;
  long unsigned int D.32760;
  long unsigned int D.32761;
  <unnamed type> D.32762;
  int D.32765;
  int D.32766;
  int D.32767;
  int D.32768;
  int D.32769;
  int D.32770;

  D.32721 = mono_jit_stats.enabled;
  if (D.32721 != 0) goto <D.32722>; else goto <D.32723>;
  <D.32722>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.32724 = mono_jit_stats.max_code_size_ratio;
  D.32725 = (double) D.32724;
  D.32726 = D.32725 / 1.0e+2;
  D.32727 = mono_jit_stats.max_ratio_method;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.32726, D.32727);
  D.32728 = mono_jit_stats.biggest_method_size;
  D.32729 = mono_jit_stats.biggest_method;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.32728, D.32729);
  D.32730 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.32730);
  D.32731 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.32731);
  D.32732 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.32732);
  D.32733 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.32733);
  D.32734 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.32734);
  D.32735 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.32735);
  D.32736 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.32736);
  D.32737 = mono_defaults.corlib;
  D.32738 = D.32737->mempool;
  D.32739 = mono_mempool_get_allocated (D.32738);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.32739);
  D.32740 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.32740);
  D.32741 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.32741);
  D.32742 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.32742);
  D.32743 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.32743);
  D.32744 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.32744);
  D.32745 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.32745);
  D.32746 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.32746);
  D.32747 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.32747);
  D.32748 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.32748);
  D.32749 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.32749);
  D.32750 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.32750);
  D.32751 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.32751);
  D.32752 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.32752);
  D.32753 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.32753);
  D.32754 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.32754);
  D.32755 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.32755);
  D.32756 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.32756);
  D.32757 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.32757);
  D.32758 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.32758);
  D.32759 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.32759);
  D.32760 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.32760);
  D.32761 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.32761);
  D.32762 = mono_security_get_mode ();
  if (D.32762 == 2) goto <D.32763>; else goto <D.32764>;
  <D.32763>:
  D.32765 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.32765);
  D.32766 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.32766);
  D.32767 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.32767);
  D.32768 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.32768);
  D.32769 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.32769);
  D.32770 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.32770);
  <D.32764>:
  D.32727 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.32727);
  mono_jit_stats.max_ratio_method = 0B;
  D.32729 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.32729);
  mono_jit_stats.biggest_method = 0B;
  <D.32723>:
}


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.32771;
  unsigned int default_opt.202;
  unsigned int default_opt.203;

  D.32771 = ~opts;
  default_opt.202 = default_opt;
  default_opt.203 = D.32771 & default_opt.202;
  default_opt = default_opt.203;
}


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


mono_set_verbose_level (guint32 level)
{
  int level.204;

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


mono_get_runtime_build_info ()
{
  const char * mono_build_date.205;
  char * D.32778;

  mono_build_date.205 = mono_build_date;
  if (mono_build_date.205 != 0B) goto <D.32776>; else goto <D.32777>;
  <D.32776>:
  mono_build_date.205 = mono_build_date;
  D.32778 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.205);
  return D.32778;
  <D.32777>:
  D.32778 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.32778;
}


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.32780;
  int mini_verbose.206;
  const char * D.32786;
  int D.32787;
  int D.32788;
  unsigned int D.32789;
  short unsigned int D.32790;
  int D.32791;
  int D.32792;
  int D.27067;
  int iftmp.207;
  int D.27066;
  const char[9] * D.32800;
  unsigned char D.32801;
  int D.32802;
  unsigned char D.32803;
  int D.32804;
  const unsigned char * D.32809;
  unsigned char D.32810;
  int D.32811;
  const unsigned char * D.32812;
  unsigned char D.32813;
  int D.32814;
  const unsigned char * D.32819;
  unsigned char D.32820;
  int D.32821;
  const unsigned char * D.32822;
  unsigned char D.32823;
  int D.32824;
  const unsigned char * D.32829;
  unsigned char D.32830;
  int D.32831;
  const unsigned char * D.32832;
  unsigned char D.32833;
  int D.32834;
  const char * D.32836;
  struct MonoClass * D.32839;
  long unsigned int D.32840;
  long unsigned int D.32841;
  struct MonoMethodSignature * D.32844;
  long unsigned int D.32845;
  long unsigned int D.32846;
  int D.32849;
  struct MonoAssembly * * D.32850;
  long unsigned int D.32851;
  long unsigned int D.32852;
  struct MonoAssembly * * D.32853;
  struct MonoAssembly * D.32854;
  int D.32857;
  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.32780 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.32780 != 0B) goto <D.32781>; else goto <D.32782>;
  <D.32781>:
  return;
  <D.32782>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.206 = mini_verbose;
  if (mini_verbose.206 > 0) goto <D.32784>; else goto <D.32785>;
  <D.32784>:
  D.32786 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.32786);
  <D.32785>:
  i = 0;
  goto <D.27069>;
  <D.27068>:
  D.32787 = i + 1;
  D.32788 = D.32787 | 100663296;
  D.32789 = (unsigned int) D.32788;
  method = mono_get_method (image, D.32789, 0B);
  D.32790 = method->flags;
  D.32791 = (int) D.32790;
  D.32792 = D.32791 & 1024;
  if (D.32792 != 0) goto <D.32793>; else goto <D.32794>;
  <D.32793>:
  // predicted unlikely by continue predictor.
  goto <D.27057>;
  <D.32794>:
  count = count + 1;
  mini_verbose.206 = mini_verbose;
  if (mini_verbose.206 > 1) goto <D.32795>; else goto <D.32796>;
  <D.32795>:
  {
    char * desc;

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

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

      __s2 = method->name;
      D.32800 = "Finalize";
      D.32801 = MEM[(const unsigned char *)D.32800];
      D.32802 = (int) D.32801;
      D.32803 = *__s2;
      D.32804 = (int) D.32803;
      __result = D.32802 - D.32804;
      {
        if (__s2_len != 0) goto <D.32805>; else goto <D.32806>;
        <D.32805>:
        if (__result == 0) goto <D.32807>; else goto <D.32808>;
        <D.32807>:
        D.32809 = &MEM[(void *)"Finalize" + 1B];
        D.32810 = *D.32809;
        D.32811 = (int) D.32810;
        D.32812 = __s2 + 1;
        D.32813 = *D.32812;
        D.32814 = (int) D.32813;
        __result = D.32811 - D.32814;
        if (__s2_len > 1) goto <D.32815>; else goto <D.32816>;
        <D.32815>:
        if (__result == 0) goto <D.32817>; else goto <D.32818>;
        <D.32817>:
        D.32819 = &MEM[(void *)"Finalize" + 2B];
        D.32820 = *D.32819;
        D.32821 = (int) D.32820;
        D.32822 = __s2 + 2;
        D.32823 = *D.32822;
        D.32824 = (int) D.32823;
        __result = D.32821 - D.32824;
        if (__s2_len > 2) goto <D.32825>; else goto <D.32826>;
        <D.32825>:
        if (__result == 0) goto <D.32827>; else goto <D.32828>;
        <D.32827>:
        D.32829 = &MEM[(void *)"Finalize" + 3B];
        D.32830 = *D.32829;
        D.32831 = (int) D.32830;
        D.32832 = __s2 + 3;
        D.32833 = *D.32832;
        D.32834 = (int) D.32833;
        __result = D.32831 - D.32834;
        <D.32828>:
        <D.32826>:
        <D.32818>:
        <D.32816>:
        <D.32808>:
        <D.32806>:
      }
      D.27066 = __result;
    }
    iftmp.207 = -D.27066;
    goto <D.32835>;
    <D.32799>:
    D.32836 = method->name;
    iftmp.207 = __builtin_strcmp (D.32836, "Finalize");
    <D.32835>:
    D.27067 = iftmp.207;
  }
  if (D.27067 == 0) goto <D.32837>; else goto <D.32838>;
  <D.32837>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.32838>:
  D.32839 = method->klass;
  D.32840 = BIT_FIELD_REF <*D.32839, 64, 256>;
  D.32841 = D.32840 & 4194304;
  if (D.32841 != 0) goto <D.32842>; else goto <D.32843>;
  <D.32842>:
  D.32844 = mono_method_signature (method);
  D.32845 = BIT_FIELD_REF <*D.32844, 64, 64>;
  D.32846 = D.32845 & 18014398509481984;
  if (D.32846 != 0) goto <D.32847>; else goto <D.32848>;
  <D.32847>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.32848>:
  <D.32843>:
  <D.27057>:
  i = i + 1;
  <D.27069>:
  D.32849 = mono_image_get_table_rows (image, 6);
  if (D.32849 > i) goto <D.27068>; else goto <D.27070>;
  <D.27070>:
  i = 0;
  goto <D.27072>;
  <D.27071>:
  mono_assembly_load_reference (image, i);
  D.32850 = image->references;
  D.32851 = (long unsigned int) i;
  D.32852 = D.32851 * 8;
  D.32853 = D.32850 + D.32852;
  D.32854 = *D.32853;
  if (D.32854 != 0B) goto <D.32855>; else goto <D.32856>;
  <D.32855>:
  D.32850 = image->references;
  D.32851 = (long unsigned int) i;
  D.32852 = D.32851 * 8;
  D.32853 = D.32850 + D.32852;
  D.32854 = *D.32853;
  mono_precompile_assembly (D.32854, assemblies);
  <D.32856>:
  i = i + 1;
  <D.27072>:
  D.32857 = mono_image_get_table_rows (image, 35);
  if (D.32857 > i) goto <D.27071>; else goto <D.27073>;
  <D.27073>:
}


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

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


mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.32861;
  long int start.208;
  unsigned char * D.32863;
  long int D.32864;
  long int D.32865;
  int D.32866;
  struct GSList * D.32867;
  struct GSList * D.32868;
  struct TryBlockHole * hole;

  D.32861 = cfg->mempool;
  hole = mono_mempool_alloc (D.32861, 24);
  hole->clause = clause;
  start.208 = (long int) start;
  D.32863 = cfg->native_code;
  D.32864 = (long int) D.32863;
  D.32865 = start.208 - D.32864;
  D.32866 = (int) D.32865;
  hole->start_offset = D.32866;
  hole->basic_block = bb;
  D.32861 = cfg->mempool;
  D.32867 = cfg->try_block_holes;
  D.32868 = g_slist_append_mempool (D.32861, D.32867, hole);
  cfg->try_block_holes = D.32868;
}


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

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


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

  D.32870 = 0;
  return D.32870;
}


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

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


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

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


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

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


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

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