mono_realloc_native_code (struct MonoCompile * cfg)
{
  void * D.29363;
  unsigned char * D.29364;
  unsigned int D.29365;

  D.29364 = cfg->native_code;
  D.29365 = cfg->code_size;
  D.29363 = monoeg_realloc (D.29364, D.29365);
  return D.29363;
}


mono_running_on_valgrind ()
{
  volatile unsigned int D.27231;
  gboolean D.29369;

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

    _zzq_args[0] = 4097;
    _zzq_args[1] = 0;
    _zzq_args[2] = 0;
    _zzq_args[3] = 0;
    _zzq_args[4] = 0;
    _zzq_args[5] = 0;
    __asm__ __volatile__("mov r3, %1
	mov r4, %2
	mov r12, r12, ror #3  ; mov r12, r12, ror #13 
	mov r12, r12, ror #29 ; mov r12, r12, ror #19 
	orr r10, r10, r10
	mov %0, r3" : "=r" _zzq_result : "r" 0, "r" &_zzq_args[0] : "r4", "r3", "memory", "cc");
    D.27231 = _zzq_result;
  }
  if (D.27231 != 0) goto <D.29367>; else goto <D.29368>;
  <D.29367>:
  D.29369 = 1;
  return D.29369;
  <D.29368>:
  D.29369 = 0;
  return D.29369;
}


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

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


get_method_from_ip (void * ip)
{
  union mono_mutex_t * D.29377;
  _Bool D.29380;
  long int D.29381;
  long int D.29382;
  void * D.29385;
  struct GHashTable * D.29386;
  _Bool D.29389;
  long int D.29390;
  long int D.29391;
  struct MonoMethod * D.29394;
  char * D.29397;
  struct MonoMethod * D.29398;
  struct MonoMethod * D.29399;
  int ip.0;
  void * D.29401;
  int D.29402;
  int D.29403;
  unsigned int D.29404;
  int D.29405;
  sizetype D.29406;
  char * D.29407;
  char * D.29408;
  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.29373>; else goto <D.29374>;
      <D.29373>:
      domain = mono_get_root_domain ();
      <D.29374>:
      ji = mono_jit_info_table_find (domain, ip);
      if (ji == 0B) goto <D.29375>; else goto <D.29376>;
      <D.29375>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.29377 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.29377);
        if (ret != 0) goto <D.29378>; else goto <D.29379>;
        <D.29378>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29379>:
        D.29380 = ret != 0;
        D.29381 = (long int) D.29380;
        D.29382 = __builtin_expect (D.29381, 0);
        if (D.29382 != 0) goto <D.29383>; else goto <D.29384>;
        <D.29383>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 305, "ret == 0");
        <D.29384>:
      }
      D.29385 = domain->runtime_info;
      D.29386 = MEM[(struct MonoJitDomainInfo *)D.29385].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.29386, find_tramp, &user_data);
      {
        int ret;

        D.29377 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.29377);
        if (ret != 0) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29388>:
        D.29389 = ret != 0;
        D.29390 = (long int) D.29389;
        D.29391 = __builtin_expect (D.29390, 0);
        if (D.29391 != 0) goto <D.29392>; else goto <D.29393>;
        <D.29392>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 307, "ret == 0");
        <D.29393>:
      }
      D.29394 = user_data.method;
      if (D.29394 != 0B) goto <D.29395>; else goto <D.29396>;
      <D.29395>:
      {
        char * mname;

        D.29394 = user_data.method;
        mname = mono_method_full_name (D.29394, 1);
        res = monoeg_g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
        monoeg_g_free (mname);
        D.29397 = res;
        return D.29397;
      }
      <D.29396>:
      D.29397 = 0B;
      return D.29397;
      <D.29376>:
      D.29398 = jinfo_get_method (ji);
      method = mono_method_full_name (D.29398, 1);
      D.29399 = jinfo_get_method (ji);
      ip.0 = (int) ip;
      D.29401 = ji->code_start;
      D.29402 = (int) D.29401;
      D.29403 = ip.0 - D.29402;
      D.29404 = (unsigned int) D.29403;
      location = mono_debug_lookup_source_location (D.29399, D.29404, domain);
      ip.0 = (int) ip;
      D.29401 = ji->code_start;
      D.29402 = (int) D.29401;
      D.29403 = ip.0 - D.29402;
      D.29401 = ji->code_start;
      D.29401 = ji->code_start;
      D.29405 = ji->code_size;
      D.29406 = (sizetype) D.29405;
      D.29407 = D.29401 + D.29406;
      D.29408 = domain->friendly_name;
      res = monoeg_g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, D.29403, D.29401, D.29407, domain, D.29408);
      mono_debug_free_source_location (location);
      monoeg_g_free (method);
      D.29397 = res;
      return D.29397;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


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

  ud = user_data;
  D.29411 = ud->ip;
  if (D.29411 == value) goto <D.29412>; else goto <D.29413>;
  <D.29412>:
  ud->method = key;
  <D.29413>:
}


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

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


mono_print_method_from_ip (void * ip)
{
  struct MonoDomain * target_domain.1;
  union mono_mutex_t * D.29419;
  _Bool D.29422;
  long int D.29423;
  long int D.29424;
  void * D.29427;
  struct GHashTable * D.29428;
  _Bool D.29431;
  long int D.29432;
  long int D.29433;
  struct MonoMethod * D.29436;
  guint8 * D.29439;
  unsigned int D.29442;
  guint8 * D.29443;
  int ip.2;
  int D.29447;
  int D.29448;
  char * D.29449;
  struct _IO_FILE * stdout.3;
  struct MonoMethod * D.29451;
  struct MonoMethod * D.29452;
  void * D.29453;
  int D.29454;
  int D.29455;
  unsigned int D.29456;
  struct MonoDomain * target_domain.4;
  gboolean * D.29463;
  gboolean * D.29465;
  int D.29466;
  sizetype D.29467;
  char * D.29468;
  char * D.29469;
  char * D.29472;
  unsigned int D.29473;
  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.29417>; else goto <D.29418>;
      <D.29417>:
      user_data.ip = ip;
      user_data.method = 0B;
      {
        int ret;

        D.29419 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.29419);
        if (ret != 0) goto <D.29420>; else goto <D.29421>;
        <D.29420>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29421>:
        D.29422 = ret != 0;
        D.29423 = (long int) D.29422;
        D.29424 = __builtin_expect (D.29423, 0);
        if (D.29424 != 0) goto <D.29425>; else goto <D.29426>;
        <D.29425>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 379, "ret == 0");
        <D.29426>:
      }
      D.29427 = domain->runtime_info;
      D.29428 = MEM[(struct MonoJitDomainInfo *)D.29427].jit_trampoline_hash;
      monoeg_g_hash_table_foreach (D.29428, find_tramp, &user_data);
      {
        int ret;

        D.29419 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.29419);
        if (ret != 0) goto <D.29429>; else goto <D.29430>;
        <D.29429>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29430>:
        D.29431 = ret != 0;
        D.29432 = (long int) D.29431;
        D.29433 = __builtin_expect (D.29432, 0);
        if (D.29433 != 0) goto <D.29434>; else goto <D.29435>;
        <D.29434>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 381, "ret == 0");
        <D.29435>:
      }
      D.29436 = user_data.method;
      if (D.29436 != 0B) goto <D.29437>; else goto <D.29438>;
      <D.29437>:
      {
        char * mname;

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

        tinfo = l->data;
        D.29439 = tinfo->code;
        if (D.29439 <= ip) goto <D.29440>; else goto <D.29441>;
        <D.29440>:
        D.29439 = tinfo->code;
        D.29442 = tinfo->code_size;
        D.29443 = D.29439 + D.29442;
        if (D.29443 >= ip) goto <D.29444>; else goto <D.29445>;
        <D.29444>:
        ip.2 = (int) ip;
        D.29439 = tinfo->code;
        D.29447 = (int) D.29439;
        D.29448 = ip.2 - D.29447;
        D.29449 = tinfo->name;
        printf ("IP %p is at offset 0x%x of trampoline \'%s\'.\n", ip, D.29448, D.29449);
        return;
        <D.29445>:
        <D.29441>:
      }
      l = l->next;
      <D.27279>:
      if (l != 0B) goto <D.27278>; else goto <D.27280>;
      <D.27280>:
      monoeg_g_print ("No method at %p\n", ip);
      stdout.3 = stdout;
      fflush (stdout.3);
      return;
      <D.29418>:
      D.29451 = jinfo_get_method (ji);
      method = mono_method_full_name (D.29451, 1);
      D.29452 = jinfo_get_method (ji);
      ip.2 = (int) ip;
      D.29453 = ji->code_start;
      D.29454 = (int) D.29453;
      D.29455 = ip.2 - D.29454;
      D.29456 = (unsigned int) D.29455;
      target_domain.4 = target_domain;
      source = mono_debug_lookup_source_location (D.29452, D.29456, target_domain.4);
      gsctx = mono_jit_info_get_generic_sharing_context (ji);
      shared_type = "";
      if (gsctx != 0B) goto <D.29458>; else goto <D.29459>;
      <D.29458>:
      D.29463 = gsctx->var_is_vt;
      if (D.29463 != 0B) goto <D.29460>; else goto <D.29464>;
      <D.29464>:
      D.29465 = gsctx->mvar_is_vt;
      if (D.29465 != 0B) goto <D.29460>; else goto <D.29461>;
      <D.29460>:
      shared_type = "gsharedvt ";
      goto <D.29462>;
      <D.29461>:
      shared_type = "gshared ";
      <D.29462>:
      <D.29459>:
      ip.2 = (int) ip;
      D.29453 = ji->code_start;
      D.29454 = (int) D.29453;
      D.29455 = ip.2 - D.29454;
      D.29453 = ji->code_start;
      D.29453 = ji->code_start;
      D.29466 = ji->code_size;
      D.29467 = (sizetype) D.29466;
      D.29468 = D.29453 + D.29467;
      target_domain.4 = target_domain;
      target_domain.4 = target_domain;
      D.29469 = 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.29455, shared_type, method, D.29453, D.29468, target_domain.4, D.29469);
      if (source != 0B) goto <D.29470>; else goto <D.29471>;
      <D.29470>:
      D.29472 = source->source_file;
      D.29473 = source->row;
      monoeg_g_print ("%s:%d\n", D.29472, D.29473);
      <D.29471>:
      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.29477;

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


mono_method_same_domain (struct MonoJitInfo * caller, struct MonoJitInfo * callee)
{
  _Bool D.29479;
  _Bool D.29480;
  _Bool D.29481;
  gboolean D.29484;
  unsigned char D.29485;
  unsigned char D.29486;
  unsigned char D.29489;
  unsigned char D.29490;
  struct MonoClass * D.29493;
  struct MonoClass * D.29494;
  const char * D.29497;
  char * D.29498;
  struct MonoMethod * cmethod;

  D.29479 = caller == 0B;
  D.29480 = callee == 0B;
  D.29481 = D.29479 | D.29480;
  if (D.29481 != 0) goto <D.29482>; else goto <D.29483>;
  <D.29482>:
  D.29484 = 0;
  return D.29484;
  <D.29483>:
  D.29485 = BIT_FIELD_REF <*caller, 8, 168>;
  D.29486 = D.29485 & 128;
  if (D.29486 != 0) goto <D.29487>; else goto <D.29488>;
  <D.29487>:
  D.29489 = BIT_FIELD_REF <*callee, 8, 168>;
  D.29490 = D.29489 & 128;
  if (D.29490 == 0) goto <D.29491>; else goto <D.29492>;
  <D.29491>:
  D.29484 = 0;
  return D.29484;
  <D.29492>:
  <D.29488>:
  cmethod = jinfo_get_method (caller);
  D.29493 = cmethod->klass;
  D.29494 = mono_defaults.appdomain_class;
  if (D.29493 == D.29494) goto <D.29495>; else goto <D.29496>;
  <D.29495>:
  D.29497 = cmethod->name;
  D.29498 = strstr (D.29497, "InvokeInDomain");
  if (D.29498 != 0B) goto <D.29499>; else goto <D.29500>;
  <D.29499>:
  D.29484 = 0;
  return D.29484;
  <D.29500>:
  <D.29496>:
  D.29484 = 1;
  return D.29484;
}


mono_global_codeman_reserve (int size)
{
  int mono_aot_only.5;
  struct MonoCodeManager * global_codeman.6;
  struct MonoCodeManager * global_codeman.7;
  void * D.29509;
  _Bool D.29512;
  long int D.29513;
  long int D.29514;
  _Bool D.29519;
  long int D.29520;
  long int D.29521;
  void * ptr;

  mono_aot_only.5 = mono_aot_only;
  if (mono_aot_only.5 != 0) goto <D.29503>; else goto <D.29504>;
  <D.29503>:
  monoeg_g_log (0B, 4, "Attempting to allocate from the global code manager while running with --aot-only.\n");
  <D.27290>:
  goto <D.27290>;
  <D.29504>:
  global_codeman.6 = global_codeman;
  if (global_codeman.6 == 0B) goto <D.29506>; else goto <D.29507>;
  <D.29506>:
  global_codeman.7 = mono_code_manager_new ();
  global_codeman = global_codeman.7;
  global_codeman.6 = global_codeman;
  D.29509 = mono_code_manager_reserve (global_codeman.6, size);
  return D.29509;
  <D.29507>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.29510>; else goto <D.29511>;
    <D.29510>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29511>:
    D.29512 = ret != 0;
    D.29513 = (long int) D.29512;
    D.29514 = __builtin_expect (D.29513, 0);
    if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
    <D.29515>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 471, "ret == 0");
    <D.29516>:
  }
  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.29517>; else goto <D.29518>;
    <D.29517>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29518>:
    D.29519 = ret != 0;
    D.29520 = (long int) D.29519;
    D.29521 = __builtin_expect (D.29520, 0);
    if (D.29521 != 0) goto <D.29522>; else goto <D.29523>;
    <D.29522>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 473, "ret == 0");
    <D.29523>:
  }
  D.29509 = ptr;
  return D.29509;
}


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

  D.29525 = data;
  return D.29525;
}


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.29527;
  short unsigned int D.29528;
  unsigned int when.8;
  struct MonoUnwindOp * D.29530;
  struct MonoUnwindOp * op;

  op = monoeg_malloc0 (12);
  D.29527 = (unsigned char) tag;
  op->op = D.29527;
  D.29528 = (short unsigned int) reg;
  op->reg = D.29528;
  op->val = val;
  when.8 = (unsigned int) when;
  op->when = when.8;
  D.29530 = op;
  return D.29530;
}


mono_emit_unwind_op (struct MonoCompile * cfg, int when, int tag, int reg, int val)
{
  struct MonoMemPool * D.29532;
  unsigned char D.29533;
  short unsigned int D.29534;
  unsigned int when.9;
  struct GSList * D.29536;
  struct GSList * D.29537;
  unsigned int D.29538;
  const char * D.29541;
  const char * D.29542;
  const char * D.29543;
  int D.29544;
  struct MonoUnwindOp * op;

  D.29532 = cfg->mempool;
  op = mono_mempool_alloc0 (D.29532, 12);
  D.29533 = (unsigned char) tag;
  op->op = D.29533;
  D.29534 = (short unsigned int) reg;
  op->reg = D.29534;
  op->val = val;
  when.9 = (unsigned int) when;
  op->when = when.9;
  D.29532 = cfg->mempool;
  D.29536 = cfg->unwind_ops;
  D.29537 = g_slist_append_mempool (D.29532, D.29536, op);
  cfg->unwind_ops = D.29537;
  D.29538 = cfg->verbose_level;
  if (D.29538 > 1) goto <D.29539>; else goto <D.29540>;
  <D.29539>:
  switch (tag) <default: <D.29545>, case 12: <D.27321>, case 13: <D.27323>, case 14: <D.27324>, case 128: <D.27325>>
  <D.27321>:
  D.29541 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa: %s+0x%x\n", when, D.29541, val);
  goto <D.27322>;
  <D.27323>:
  D.29542 = mono_arch_regname (reg);
  printf ("CFA: [%x] def_cfa_reg: %s\n", when, D.29542);
  goto <D.27322>;
  <D.27324>:
  printf ("CFA: [%x] def_cfa_offset: 0x%x\n", when, val);
  goto <D.27322>;
  <D.27325>:
  D.29543 = mono_arch_regname (reg);
  D.29544 = -val;
  printf ("CFA: [%x] offset: %s at cfa-0x%x\n", when, D.29543, D.29544);
  goto <D.27322>;
  <D.29545>:
  <D.27322>:
  <D.29540>:
}


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

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.29546>; else goto <D.29547>;
  <D.29546>:
  last = list;
  goto <D.16496>;
  <D.16495>:
  last = last->next;
  <D.16496>:
  D.29548 = last->next;
  if (D.29548 != 0B) goto <D.16495>; else goto <D.16497>;
  <D.16497>:
  last->next = new_list;
  D.29549 = list;
  return D.29549;
  <D.29547>:
  D.29549 = new_list;
  return D.29549;
}


mono_jump_info_token_new2 (struct MonoMemPool * mp, struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  _Bool D.29551;
  int D.29552;
  struct MonoGenericContext * D.29555;
  struct MonoJumpInfoToken * D.29556;
  struct MonoJumpInfoToken * res;

  res = mono_mempool_alloc0 (mp, 20);
  res->image = image;
  res->token = token;
  D.29551 = context != 0B;
  D.29552 = (int) D.29551;
  res->has_context = D.29552;
  if (context != 0B) goto <D.29553>; else goto <D.29554>;
  <D.29553>:
  D.29555 = &res->context;
  memcpy (D.29555, context, 8);
  <D.29554>:
  D.29556 = res;
  return D.29556;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.29558;
  unsigned int D.29559;

  D.29559 = __builtin_object_size (__dest, 0);
  D.29558 = __builtin___memcpy_chk (__dest, __src, __len, D.29559);
  return D.29558;
}


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

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


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

  info = monoeg_malloc0 (28);
  D.29563 = monoeg_strdup (name);
  info->name = D.29563;
  info->code = code;
  info->code_size = code_size;
  info->ji = ji;
  info->unwind_ops = unwind_ops;
  D.29564 = info;
  return D.29564;
}


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

  if (str != 0B) goto <D.29566>; else goto <D.29567>;
  <D.29566>:
  D.29568 = __strdup (str);
  return D.29568;
  <D.29567>:
  D.29568 = 0B;
  return D.29568;
}


mono_tramp_info_free (struct MonoTrampInfo * info)
{
  char * D.29570;
  void * D.29571;
  struct GSList * D.29572;
  struct GSList * l;

  D.29570 = info->name;
  monoeg_g_free (D.29570);
  l = info->unwind_ops;
  goto <D.27351>;
  <D.27350>:
  D.29571 = l->data;
  monoeg_g_free (D.29571);
  l = l->next;
  <D.27351>:
  if (l != 0B) goto <D.27350>; else goto <D.27352>;
  <D.27352>:
  D.29572 = info->unwind_ops;
  monoeg_g_slist_free (D.29572);
  monoeg_g_free (info);
}


mono_tramp_info_register (struct MonoTrampInfo * info)
{
  guint8 * D.29575;
  unsigned int D.29576;
  char * D.29577;
  gchar * D.29578;
  _Bool D.29581;
  long int D.29582;
  long int D.29583;
  struct GSList * tramp_infos.10;
  struct GSList * tramp_infos.11;
  _Bool D.29590;
  long int D.29591;
  long int D.29592;
  int D.29595;
  int D.29598;
  struct MonoTrampInfo * copy;

  if (info == 0B) goto <D.29573>; else goto <D.29574>;
  <D.29573>:
  return;
  <D.29574>:
  copy = monoeg_malloc0 (28);
  D.29575 = info->code;
  copy->code = D.29575;
  D.29576 = info->code_size;
  copy->code_size = D.29576;
  D.29577 = info->name;
  D.29578 = monoeg_strdup (D.29577);
  copy->name = D.29578;
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.29579>; else goto <D.29580>;
    <D.29579>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29580>:
    D.29581 = ret != 0;
    D.29582 = (long int) D.29581;
    D.29583 = __builtin_expect (D.29582, 0);
    if (D.29583 != 0) goto <D.29584>; else goto <D.29585>;
    <D.29584>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 673, "ret == 0");
    <D.29585>:
  }
  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.29588>; else goto <D.29589>;
    <D.29588>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29589>:
    D.29590 = ret != 0;
    D.29591 = (long int) D.29590;
    D.29592 = __builtin_expect (D.29591, 0);
    if (D.29592 != 0) goto <D.29593>; else goto <D.29594>;
    <D.29593>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 675, "ret == 0");
    <D.29594>:
  }
  mono_save_trampoline_xdebug_info (info);
  D.29595 = mono_jit_map_is_enabled ();
  if (D.29595 != 0) goto <D.29596>; else goto <D.29597>;
  <D.29596>:
  D.29575 = info->code;
  D.29576 = info->code_size;
  D.29598 = (int) D.29576;
  D.29577 = info->name;
  mono_emit_jit_tramp (D.29575, D.29598, D.29577);
  <D.29597>:
  mono_tramp_info_free (info);
}


mono_debug_count ()
{
  int count.12;
  int count.13;
  const gchar * D.29602;
  gboolean D.29605;
  const gchar * D.29606;
  int D.29607;
  const gchar * D.29610;
  int D.29611;
  static int count = 0;

  count.12 = count;
  count.13 = count.12 + 1;
  count = count.13;
  D.29602 = monoeg_g_getenv ("COUNT");
  if (D.29602 == 0B) goto <D.29603>; else goto <D.29604>;
  <D.29603>:
  D.29605 = 1;
  return D.29605;
  <D.29604>:
  D.29606 = monoeg_g_getenv ("COUNT");
  D.29607 = atoi (D.29606);
  count.12 = count;
  if (D.29607 == count.12) goto <D.29608>; else goto <D.29609>;
  <D.29608>:
  break_count ();
  <D.29609>:
  D.29610 = monoeg_g_getenv ("COUNT");
  D.29611 = atoi (D.29610);
  count.12 = count;
  if (D.29611 < count.12) goto <D.29612>; else goto <D.29613>;
  <D.29612>:
  D.29605 = 0;
  return D.29605;
  <D.29613>:
  D.29605 = 1;
  return D.29605;
}


break_count ()
{

}


atoi (const char * __nptr)
{
  int D.29615;

  D.29615 = strtol (__nptr, 0B, 10);
  return D.29615;
}


mono_unlink_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.29617;
  unsigned int i.14;
  unsigned int D.29619;
  struct MonoBasicBlock * * D.29620;
  struct MonoBasicBlock * D.29621;
  short int D.29624;
  int D.29625;
  int pos.15;
  unsigned int pos.16;
  unsigned int D.29632;
  struct MonoBasicBlock * * D.29633;
  int D.29634;
  _Bool D.29635;
  long int D.29636;
  long int D.29637;
  short int D.29640;
  unsigned short D.29641;
  unsigned short D.29642;
  short int D.29643;
  struct MonoBasicBlock * * D.29644;
  struct MonoBasicBlock * * D.29645;
  struct MonoBasicBlock * D.29646;
  short int D.29649;
  int D.29650;
  int pos.17;
  unsigned int pos.18;
  unsigned int D.29657;
  struct MonoBasicBlock * * D.29658;
  int D.29659;
  _Bool D.29660;
  long int D.29661;
  long int D.29662;
  short int D.29665;
  unsigned short D.29666;
  unsigned short D.29667;
  short int D.29668;
  int i;
  int pos;
  gboolean found;

  found = 0;
  i = 0;
  goto <D.27376>;
  <D.27375>:
  D.29617 = from->out_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29620 = D.29617 + D.29619;
  D.29621 = *D.29620;
  if (D.29621 == to) goto <D.29622>; else goto <D.29623>;
  <D.29622>:
  found = 1;
  goto <D.27374>;
  <D.29623>:
  i = i + 1;
  <D.27376>:
  D.29624 = from->out_count;
  D.29625 = (int) D.29624;
  if (D.29625 > i) goto <D.27375>; else goto <D.27374>;
  <D.27374>:
  if (found != 0) goto <D.29626>; else goto <D.29627>;
  <D.29626>:
  pos = 0;
  i = 0;
  goto <D.27378>;
  <D.27377>:
  D.29617 = from->out_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29620 = D.29617 + D.29619;
  D.29621 = *D.29620;
  if (D.29621 != to) goto <D.29628>; else goto <D.29629>;
  <D.29628>:
  D.29617 = from->out_bb;
  pos.15 = pos;
  pos = pos.15 + 1;
  pos.16 = (unsigned int) pos.15;
  D.29632 = pos.16 * 4;
  D.29633 = D.29617 + D.29632;
  D.29617 = from->out_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29620 = D.29617 + D.29619;
  D.29621 = *D.29620;
  *D.29633 = D.29621;
  <D.29629>:
  i = i + 1;
  <D.27378>:
  D.29624 = from->out_count;
  D.29625 = (int) D.29624;
  if (D.29625 > i) goto <D.27377>; else goto <D.27379>;
  <D.27379>:
  D.29624 = from->out_count;
  D.29625 = (int) D.29624;
  D.29634 = D.29625 + -1;
  D.29635 = D.29634 != pos;
  D.29636 = (long int) D.29635;
  D.29637 = __builtin_expect (D.29636, 0);
  if (D.29637 != 0) goto <D.29638>; else goto <D.29639>;
  <D.29638>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 744, "pos == from->out_count - 1");
  <D.29639>:
  D.29624 = from->out_count;
  D.29640 = D.29624;
  D.29641 = (unsigned short) D.29640;
  D.29642 = D.29641 + 65535;
  D.29643 = (short int) D.29642;
  from->out_count = D.29643;
  <D.29627>:
  found = 0;
  i = 0;
  goto <D.27382>;
  <D.27381>:
  D.29644 = to->in_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29645 = D.29644 + D.29619;
  D.29646 = *D.29645;
  if (D.29646 == from) goto <D.29647>; else goto <D.29648>;
  <D.29647>:
  found = 1;
  goto <D.27380>;
  <D.29648>:
  i = i + 1;
  <D.27382>:
  D.29649 = to->in_count;
  D.29650 = (int) D.29649;
  if (D.29650 > i) goto <D.27381>; else goto <D.27380>;
  <D.27380>:
  if (found != 0) goto <D.29651>; else goto <D.29652>;
  <D.29651>:
  pos = 0;
  i = 0;
  goto <D.27384>;
  <D.27383>:
  D.29644 = to->in_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29645 = D.29644 + D.29619;
  D.29646 = *D.29645;
  if (D.29646 != from) goto <D.29653>; else goto <D.29654>;
  <D.29653>:
  D.29644 = to->in_bb;
  pos.17 = pos;
  pos = pos.17 + 1;
  pos.18 = (unsigned int) pos.17;
  D.29657 = pos.18 * 4;
  D.29658 = D.29644 + D.29657;
  D.29644 = to->in_bb;
  i.14 = (unsigned int) i;
  D.29619 = i.14 * 4;
  D.29645 = D.29644 + D.29619;
  D.29646 = *D.29645;
  *D.29658 = D.29646;
  <D.29654>:
  i = i + 1;
  <D.27384>:
  D.29649 = to->in_count;
  D.29650 = (int) D.29649;
  if (D.29650 > i) goto <D.27383>; else goto <D.27385>;
  <D.27385>:
  D.29649 = to->in_count;
  D.29650 = (int) D.29649;
  D.29659 = D.29650 + -1;
  D.29660 = D.29659 != pos;
  D.29661 = (long int) D.29660;
  D.29662 = __builtin_expect (D.29661, 0);
  if (D.29662 != 0) goto <D.29663>; else goto <D.29664>;
  <D.29663>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 761, "pos == to->in_count - 1");
  <D.29664>:
  D.29649 = to->in_count;
  D.29665 = D.29649;
  D.29666 = (unsigned short) D.29665;
  D.29667 = D.29666 + 65535;
  D.29668 = (short int) D.29667;
  to->in_count = D.29668;
  <D.29652>:
}


mono_bblocks_linked (struct MonoBasicBlock * bb1, struct MonoBasicBlock * bb2)
{
  struct MonoBasicBlock * * D.29669;
  unsigned int i.19;
  unsigned int D.29671;
  struct MonoBasicBlock * * D.29672;
  struct MonoBasicBlock * D.29673;
  gboolean D.29676;
  short int D.29677;
  int D.29678;
  int i;

  i = 0;
  goto <D.27392>;
  <D.27391>:
  D.29669 = bb1->out_bb;
  i.19 = (unsigned int) i;
  D.29671 = i.19 * 4;
  D.29672 = D.29669 + D.29671;
  D.29673 = *D.29672;
  if (D.29673 == bb2) goto <D.29674>; else goto <D.29675>;
  <D.29674>:
  D.29676 = 1;
  return D.29676;
  <D.29675>:
  i = i + 1;
  <D.27392>:
  D.29677 = bb1->out_count;
  D.29678 = (int) D.29677;
  if (D.29678 > i) goto <D.27391>; else goto <D.27393>;
  <D.27393>:
  D.29676 = 0;
  return D.29676;
}


mono_get_block_region_notry (struct MonoCompile * cfg, int region)
{
  int D.29680;
  int D.29683;
  int iftmp.20;
  <unnamed-unsigned:15> D.29689;
  int D.29690;
  _Bool D.29691;
  long int D.29692;
  long int D.29693;
  struct MonoExceptionClause * D.29696;
  unsigned int clause_index.21;
  unsigned int D.29698;
  struct MonoExceptionClause * D.29699;
  unsigned int D.29700;
  int D.29701;
  int D.29702;

  D.29680 = region & 240;
  if (D.29680 == 0) goto <D.29681>; else goto <D.29682>;
  <D.29681>:
  {
    struct MonoMethodHeader * header;
    int clause_index;

    header = cfg->header;
    D.29683 = region >> 8;
    clause_index = D.29683 + -1;
    if (clause_index < 0) goto <D.29685>; else goto <D.29688>;
    <D.29688>:
    D.29689 = header->num_clauses;
    D.29690 = (int) D.29689;
    if (D.29690 <= clause_index) goto <D.29685>; else goto <D.29686>;
    <D.29685>:
    iftmp.20 = 1;
    goto <D.29687>;
    <D.29686>:
    iftmp.20 = 0;
    <D.29687>:
    D.29691 = iftmp.20 != 0;
    D.29692 = (long int) D.29691;
    D.29693 = __builtin_expect (D.29692, 0);
    if (D.29693 != 0) goto <D.29694>; else goto <D.29695>;
    <D.29694>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 826, "clause_index >= 0 && clause_index < header->num_clauses");
    <D.29695>:
    D.29696 = header->clauses;
    clause_index.21 = (unsigned int) clause_index;
    D.29698 = clause_index.21 * 24;
    D.29699 = D.29696 + D.29698;
    D.29700 = D.29699->try_offset;
    D.29701 = (int) D.29700;
    region = mono_find_block_region_notry (cfg, D.29701);
  }
  <D.29682>:
  D.29702 = region;
  return D.29702;
}


mono_find_block_region_notry (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.29704;
  unsigned int i.22;
  unsigned int D.29706;
  unsigned int D.29707;
  unsigned int offset.23;
  unsigned int D.29711;
  unsigned int D.29714;
  int D.29717;
  int D.29718;
  int D.29719;
  unsigned int D.29720;
  unsigned int D.29721;
  unsigned int D.29722;
  unsigned int D.29725;
  unsigned int D.29726;
  unsigned int D.29731;
  unsigned int D.29734;
  unsigned int D.29735;
  <unnamed-unsigned:15> D.29736;
  int D.29737;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.27402>;
  <D.27401>:
  D.29704 = header->clauses;
  i.22 = (unsigned int) i;
  D.29706 = i.22 * 24;
  clause = D.29704 + D.29706;
  D.29707 = clause->flags;
  if (D.29707 == 1) goto <D.29708>; else goto <D.29709>;
  <D.29708>:
  offset.23 = (unsigned int) offset;
  D.29711 = clause->data.filter_offset;
  if (offset.23 >= D.29711) goto <D.29712>; else goto <D.29713>;
  <D.29712>:
  offset.23 = (unsigned int) offset;
  D.29714 = clause->handler_offset;
  if (offset.23 < D.29714) goto <D.29715>; else goto <D.29716>;
  <D.29715>:
  D.29718 = i + 1;
  D.29719 = D.29718 << 8;
  D.29720 = (unsigned int) D.29719;
  D.29707 = clause->flags;
  D.29721 = D.29720 | D.29707;
  D.29722 = D.29721 | 128;
  D.29717 = (int) D.29722;
  return D.29717;
  <D.29716>:
  <D.29713>:
  <D.29709>:
  D.29714 = clause->handler_offset;
  offset.23 = (unsigned int) offset;
  if (D.29714 <= offset.23) goto <D.29723>; else goto <D.29724>;
  <D.29723>:
  offset.23 = (unsigned int) offset;
  D.29714 = clause->handler_offset;
  D.29725 = clause->handler_len;
  D.29726 = D.29714 + D.29725;
  if (offset.23 < D.29726) goto <D.29727>; else goto <D.29728>;
  <D.29727>:
  D.29707 = clause->flags;
  if (D.29707 == 2) goto <D.29729>; else goto <D.29730>;
  <D.29729>:
  D.29718 = i + 1;
  D.29719 = D.29718 << 8;
  D.29720 = (unsigned int) D.29719;
  D.29707 = clause->flags;
  D.29721 = D.29720 | D.29707;
  D.29731 = D.29721 | 16;
  D.29717 = (int) D.29731;
  return D.29717;
  <D.29730>:
  D.29707 = clause->flags;
  if (D.29707 == 4) goto <D.29732>; else goto <D.29733>;
  <D.29732>:
  D.29718 = i + 1;
  D.29719 = D.29718 << 8;
  D.29720 = (unsigned int) D.29719;
  D.29707 = clause->flags;
  D.29721 = D.29720 | D.29707;
  D.29734 = D.29721 | 64;
  D.29717 = (int) D.29734;
  return D.29717;
  <D.29733>:
  D.29718 = i + 1;
  D.29719 = D.29718 << 8;
  D.29720 = (unsigned int) D.29719;
  D.29707 = clause->flags;
  D.29721 = D.29720 | D.29707;
  D.29735 = D.29721 | 32;
  D.29717 = (int) D.29735;
  return D.29717;
  <D.29728>:
  <D.29724>:
  i = i + 1;
  <D.27402>:
  D.29736 = header->num_clauses;
  D.29737 = (int) D.29736;
  if (D.29737 > i) goto <D.27401>; else goto <D.27403>;
  <D.27403>:
  D.29717 = -1;
  return D.29717;
}


mono_find_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct MonoInst * D.29739;
  struct GHashTable * D.29740;
  const void * region.24;

  region = mono_get_block_region_notry (cfg, region);
  D.29740 = cfg->spvars;
  region.24 = (const void *) region;
  D.29739 = monoeg_g_hash_table_lookup (D.29740, region.24);
  return D.29739;
}


mono_reverse_branch_op (guint32 opcode)
{
  unsigned int D.29743;
  int D.29746;
  unsigned int D.29748;
  int D.29751;
  unsigned int D.29753;
  int D.29756;
  unsigned int D.29758;
  int D.29761;
  guint32 D.29763;
  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.29743 = opcode + 4294967237;
  if (D.29743 <= 9) goto <D.29744>; else goto <D.29745>;
  <D.29744>:
  D.29743 = opcode + 4294967237;
  D.29746 = reverse_map[D.29743];
  opcode = (guint32) D.29746;
  goto <D.29747>;
  <D.29745>:
  D.29748 = opcode + 4294966638;
  if (D.29748 <= 9) goto <D.29749>; else goto <D.29750>;
  <D.29749>:
  D.29748 = opcode + 4294966638;
  D.29751 = reverse_fmap[D.29748];
  opcode = (guint32) D.29751;
  goto <D.29752>;
  <D.29750>:
  D.29753 = opcode + 4294966745;
  if (D.29753 <= 9) goto <D.29754>; else goto <D.29755>;
  <D.29754>:
  D.29753 = opcode + 4294966745;
  D.29756 = reverse_lmap[D.29753];
  opcode = (guint32) D.29756;
  goto <D.29757>;
  <D.29755>:
  D.29758 = opcode + 4294966648;
  if (D.29758 <= 9) goto <D.29759>; else goto <D.29760>;
  <D.29759>:
  D.29758 = opcode + 4294966648;
  D.29761 = reverse_imap[D.29758];
  opcode = (guint32) D.29761;
  goto <D.29762>;
  <D.29760>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 889);
  <D.29762>:
  <D.29757>:
  <D.29752>:
  <D.29747>:
  D.29763 = opcode;
  return D.29763;
}


mono_type_to_store_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.29765;
  unsigned char D.29766;
  guint D.29769;
  unsigned char D.29770;
  int D.29771;
  struct MonoClass * D.29772;
  unsigned char D.29773;
  unsigned char D.29774;
  struct MonoGenericClass * D.29779;
  struct MonoClass * D.29780;
  int D.29781;
  void handle_enum = <<< error >>>;

  D.29765 = BIT_FIELD_REF <*type, 8, 56>;
  D.29766 = D.29765 & 64;
  if (D.29766 != 0) goto <D.29767>; else goto <D.29768>;
  <D.29767>:
  D.29769 = 374;
  return D.29769;
  <D.29768>:
  type = mini_replace_type (type);
  handle_enum:
  D.29770 = type->type;
  D.29771 = (int) D.29770;
  switch (D.29771) <default: <D.27462>, case 2: <D.27438>, case 3: <D.27441>, case 4: <D.27436>, case 5: <D.27437>, case 6: <D.27439>, case 7: <D.27440>, case 8: <D.27442>, case 9: <D.27443>, case 10: <D.27453>, case 11: <D.27454>, case 12: <D.27455>, case 13: <D.27456>, case 14: <D.27449>, case 15: <D.27446>, case 17: <D.27457>, case 18: <D.27448>, case 19: <D.27460>, case 20: <D.27452>, case 21: <D.27459>, case 22: <D.27458>, case 24: <D.27444>, case 25: <D.27445>, case 27: <D.27447>, case 28: <D.27450>, case 29: <D.27451>, case 30: <D.27461>>
  <D.27436>:
  <D.27437>:
  <D.27438>:
  D.29769 = 375;
  return D.29769;
  <D.27439>:
  <D.27440>:
  <D.27441>:
  D.29769 = 376;
  return D.29769;
  <D.27442>:
  <D.27443>:
  D.29769 = 377;
  return D.29769;
  <D.27444>:
  <D.27445>:
  <D.27446>:
  <D.27447>:
  D.29769 = 374;
  return D.29769;
  <D.27448>:
  <D.27449>:
  <D.27450>:
  <D.27451>:
  <D.27452>:
  D.29769 = 374;
  return D.29769;
  <D.27453>:
  <D.27454>:
  D.29769 = 378;
  return D.29769;
  <D.27455>:
  D.29769 = 379;
  return D.29769;
  <D.27456>:
  D.29769 = 380;
  return D.29769;
  <D.27457>:
  D.29772 = type->data.klass;
  D.29773 = BIT_FIELD_REF <*D.29772, 8, 160>;
  D.29774 = D.29773 & 16;
  if (D.29774 != 0) goto <D.29775>; else goto <D.29776>;
  <D.29775>:
  D.29772 = type->data.klass;
  type = mono_class_enum_basetype (D.29772);
  goto handle_enum;
  <D.29776>:
  if (0 != 0) goto <D.29777>; else goto <D.29778>;
  <D.29777>:
  D.29769 = 386;
  return D.29769;
  <D.29778>:
  D.29769 = 387;
  return D.29769;
  <D.27458>:
  D.29769 = 387;
  return D.29769;
  <D.27459>:
  D.29779 = type->data.generic_class;
  D.29780 = D.29779->container_class;
  type = &D.29780->byval_arg;
  goto handle_enum;
  <D.27460>:
  <D.27461>:
  D.29781 = mini_type_var_is_vt (cfg, type);
  if (D.29781 != 0) goto <D.29782>; else goto <D.29783>;
  <D.29782>:
  D.29769 = 387;
  return D.29769;
  <D.29783>:
  D.29769 = 374;
  return D.29769;
  <D.27462>:
  D.29770 = type->type;
  D.29771 = (int) D.29770;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_store_membase", D.29771);
  <D.27463>:
  goto <D.27463>;
  D.29769 = 4294967295;
  return D.29769;
}


mono_type_to_load_membase (struct MonoCompile * cfg, struct MonoType * type)
{
  unsigned char D.29785;
  unsigned char D.29786;
  guint D.29789;
  unsigned char D.29790;
  int D.29791;
  int D.29794;
  struct MonoGenericSharingContext * D.29797;
  _Bool D.29798;
  long int D.29799;
  long int D.29800;
  int D.29803;

  D.29785 = BIT_FIELD_REF <*type, 8, 56>;
  D.29786 = D.29785 & 64;
  if (D.29786 != 0) goto <D.29787>; else goto <D.29788>;
  <D.29787>:
  D.29789 = 388;
  return D.29789;
  <D.29788>:
  type = mini_replace_type (type);
  D.29790 = type->type;
  D.29791 = (int) D.29790;
  switch (D.29791) <default: <D.27494>, case 2: <D.27470>, case 3: <D.27473>, case 4: <D.27468>, case 5: <D.27469>, case 6: <D.27471>, case 7: <D.27472>, case 8: <D.27474>, case 9: <D.27475>, case 10: <D.27485>, case 11: <D.27486>, case 12: <D.27487>, case 13: <D.27488>, case 14: <D.27481>, case 15: <D.27478>, case 17: <D.27489>, case 18: <D.27480>, case 19: <D.27492>, case 20: <D.27484>, case 21: <D.27491>, case 22: <D.27490>, case 24: <D.27476>, case 25: <D.27477>, case 27: <D.27479>, case 28: <D.27482>, case 29: <D.27483>, case 30: <D.27493>>
  <D.27468>:
  D.29789 = 389;
  return D.29789;
  <D.27469>:
  <D.27470>:
  D.29789 = 390;
  return D.29789;
  <D.27471>:
  D.29789 = 391;
  return D.29789;
  <D.27472>:
  <D.27473>:
  D.29789 = 392;
  return D.29789;
  <D.27474>:
  D.29789 = 393;
  return D.29789;
  <D.27475>:
  D.29789 = 394;
  return D.29789;
  <D.27476>:
  <D.27477>:
  <D.27478>:
  <D.27479>:
  D.29789 = 388;
  return D.29789;
  <D.27480>:
  <D.27481>:
  <D.27482>:
  <D.27483>:
  <D.27484>:
  D.29789 = 388;
  return D.29789;
  <D.27485>:
  <D.27486>:
  D.29789 = 395;
  return D.29789;
  <D.27487>:
  D.29789 = 396;
  return D.29789;
  <D.27488>:
  D.29789 = 397;
  return D.29789;
  <D.27489>:
  if (0 != 0) goto <D.29792>; else goto <D.29793>;
  <D.29792>:
  D.29789 = 398;
  return D.29789;
  <D.29793>:
  <D.27490>:
  D.29789 = 399;
  return D.29789;
  <D.27491>:
  D.29794 = mono_type_generic_inst_is_valuetype (type);
  if (D.29794 != 0) goto <D.29795>; else goto <D.29796>;
  <D.29795>:
  D.29789 = 399;
  return D.29789;
  <D.29796>:
  D.29789 = 388;
  return D.29789;
  <D.27492>:
  <D.27493>:
  D.29797 = cfg->generic_sharing_context;
  D.29798 = D.29797 == 0B;
  D.29799 = (long int) D.29798;
  D.29800 = __builtin_expect (D.29799, 0);
  if (D.29800 != 0) goto <D.29801>; else goto <D.29802>;
  <D.29801>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1012, "cfg->generic_sharing_context");
  <D.29802>:
  D.29803 = mini_type_var_is_vt (cfg, type);
  if (D.29803 != 0) goto <D.29804>; else goto <D.29805>;
  <D.29804>:
  D.29789 = 399;
  return D.29789;
  <D.29805>:
  D.29789 = 388;
  return D.29789;
  <D.27494>:
  D.29790 = type->type;
  D.29791 = (int) D.29790;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_load_membase", D.29791);
  <D.27495>:
  goto <D.27495>;
  D.29789 = 4294967295;
  return D.29789;
}


mini_type_to_stind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.29807;
  unsigned char D.29810;
  unsigned char D.29811;
  unsigned char D.29814;
  _Bool D.29815;
  _Bool D.29816;
  _Bool D.29817;
  int D.29820;
  guint D.29823;

  type = mini_replace_type (type);
  D.29807 = cfg->generic_sharing_context;
  if (D.29807 != 0B) goto <D.29808>; else goto <D.29809>;
  <D.29808>:
  D.29810 = BIT_FIELD_REF <*type, 8, 56>;
  D.29811 = D.29810 & 64;
  if (D.29811 == 0) goto <D.29812>; else goto <D.29813>;
  <D.29812>:
  D.29814 = type->type;
  D.29815 = D.29814 == 19;
  D.29816 = D.29814 == 30;
  D.29817 = D.29815 | D.29816;
  if (D.29817 != 0) goto <D.29818>; else goto <D.29819>;
  <D.29818>:
  D.29820 = mini_type_var_is_vt (cfg, type);
  if (D.29820 != 0) goto <D.29821>; else goto <D.29822>;
  <D.29821>:
  D.29823 = 129;
  return D.29823;
  <D.29822>:
  D.29823 = 81;
  return D.29823;
  <D.29819>:
  <D.29813>:
  <D.29809>:
  D.29823 = mono_type_to_stind (type);
  return D.29823;
}


mono_op_imm_to_op (int opcode)
{
  int D.29825;
  const char * D.29826;

  switch (opcode) <default: <D.27543>, case 323: <D.27540>, case 327: <D.27541>, case 339: <D.27542>, case 429: <D.27507>, case 432: <D.27532>, case 434: <D.27533>, case 436: <D.27513>, case 437: <D.27514>, case 438: <D.27515>, case 538: <D.27509>, case 539: <D.27511>, case 541: <D.27517>, case 542: <D.27519>, case 543: <D.27521>, case 544: <D.27523>, case 545: <D.27525>, case 546: <D.27527>, case 620: <D.27538>, case 622: <D.27539>, case 625: <D.27508>, case 626: <D.27510>, case 627: <D.27512>, case 628: <D.27528>, case 629: <D.27529>, case 630: <D.27531>, case 631: <D.27530>, case 632: <D.27516>, case 633: <D.27518>, case 634: <D.27520>, case 635: <D.27522>, case 636: <D.27524>, case 637: <D.27526>, case 752: <D.27535>, case 754: <D.27537>, case 756: <D.27534>, case 758: <D.27536>>
  <D.27507>:
  D.29825 = 565;
  return D.29825;
  <D.27508>:
  D.29825 = 565;
  return D.29825;
  <D.27509>:
  D.29825 = 479;
  return D.29825;
  <D.27510>:
  D.29825 = 566;
  return D.29825;
  <D.27511>:
  D.29825 = 480;
  return D.29825;
  <D.27512>:
  D.29825 = 567;
  return D.29825;
  <D.27513>:
  D.29825 = 572;
  return D.29825;
  <D.27514>:
  D.29825 = 573;
  return D.29825;
  <D.27515>:
  D.29825 = 574;
  return D.29825;
  <D.27516>:
  D.29825 = 572;
  return D.29825;
  <D.27517>:
  D.29825 = 486;
  return D.29825;
  <D.27518>:
  D.29825 = 573;
  return D.29825;
  <D.27519>:
  D.29825 = 487;
  return D.29825;
  <D.27520>:
  D.29825 = 574;
  return D.29825;
  <D.27521>:
  D.29825 = 488;
  return D.29825;
  <D.27522>:
  D.29825 = 575;
  return D.29825;
  <D.27523>:
  D.29825 = 489;
  return D.29825;
  <D.27524>:
  D.29825 = 576;
  return D.29825;
  <D.27525>:
  D.29825 = 490;
  return D.29825;
  <D.27526>:
  D.29825 = 577;
  return D.29825;
  <D.27527>:
  D.29825 = 491;
  return D.29825;
  <D.27528>:
  D.29825 = 568;
  return D.29825;
  <D.27529>:
  D.29825 = 569;
  return D.29825;
  <D.27530>:
  D.29825 = 571;
  return D.29825;
  <D.27531>:
  D.29825 = 570;
  return D.29825;
  <D.27532>:
  D.29825 = 568;
  return D.29825;
  <D.27533>:
  D.29825 = 570;
  return D.29825;
  <D.27534>:
  D.29825 = 755;
  return D.29825;
  <D.27535>:
  D.29825 = 751;
  return D.29825;
  <D.27536>:
  D.29825 = 757;
  return D.29825;
  <D.27537>:
  D.29825 = 753;
  return D.29825;
  <D.27538>:
  D.29825 = 619;
  return D.29825;
  <D.27539>:
  D.29825 = 621;
  return D.29825;
  <D.27540>:
  D.29825 = 322;
  return D.29825;
  <D.27541>:
  D.29825 = 326;
  return D.29825;
  <D.27542>:
  D.29825 = 338;
  return D.29825;
  <D.27543>:
  D.29826 = mono_inst_name (opcode);
  printf ("%s\n", D.29826);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 1157);
  D.29825 = -1;
  return D.29825;
}


mono_decompose_op_imm (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.29828;
  int D.29829;
  struct MonoInst * D.29830;
  int D.29831;
  int D.29832;
  const unsigned char * D.29833;
  int D.29834;
  unsigned int D.29835;
  int D.29836;
  short unsigned int D.29837;
  int D.29838;
  int D.29839;
  short unsigned int D.29840;
  int D.29843;
  unsigned int D.29845;
  unsigned int D.29846;
  unsigned int D.29847;
  struct MonoInst * temp;

  D.29828 = cfg->mempool;
  temp = mono_mempool_alloc (D.29828, 56);
  temp->data.op[1].const_val = 0;
  D.29829 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.29829;
  temp->prev = 0B;
  D.29830 = temp->prev;
  temp->next = D.29830;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.29831 = temp->sreg3;
  temp->sreg2 = D.29831;
  D.29832 = temp->sreg2;
  temp->sreg1 = D.29832;
  D.29833 = cfg->ip;
  temp->cil_code = D.29833;
  D.29834 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.29834;
  D.29835 = mono_alloc_ireg (cfg);
  D.29836 = (int) D.29835;
  temp->dreg = D.29836;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.29837 = ins->opcode;
  D.29838 = (int) D.29837;
  D.29839 = mono_op_imm_to_op (D.29838);
  D.29840 = (short unsigned int) D.29839;
  ins->opcode = D.29840;
  D.29837 = ins->opcode;
  if (D.29837 == 338) goto <D.29841>; else goto <D.29842>;
  <D.29841>:
  D.29843 = temp->dreg;
  ins->sreg1 = D.29843;
  goto <D.29844>;
  <D.29842>:
  D.29843 = temp->dreg;
  ins->sreg2 = D.29843;
  <D.29844>:
  D.29845 = cfg->next_vreg;
  D.29846 = bb->max_vreg;
  D.29847 = MAX_EXPR <D.29845, D.29846>;
  bb->max_vreg = D.29847;
}


mono_compile_create_var_for_vreg (struct MonoCompile * cfg, struct MonoType * type, int opcode, int vreg)
{
  unsigned int D.29848;
  int D.29849;
  unsigned int D.29850;
  unsigned int D.29851;
  guint iftmp.25;
  struct MonoInst * * D.29858;
  unsigned int D.29859;
  void * D.29860;
  struct MonoMethodVar * D.29861;
  unsigned int D.29862;
  void * D.29863;
  unsigned int orig_count.26;
  unsigned int D.29865;
  void * D.29866;
  unsigned int orig_count.27;
  unsigned int D.29868;
  unsigned int D.29869;
  int D.29870;
  int D.29871;
  struct MonoMemPool * D.29872;
  int D.29873;
  struct MonoInst * D.29874;
  short unsigned int D.29875;
  int D.29876;
  int D.29877;
  const unsigned char * D.29878;
  struct MonoClass * D.29879;
  struct MonoClass * D.29880;
  unsigned char D.29881;
  unsigned char D.29884;
  unsigned char D.29885;
  unsigned char D.29888;
  unsigned char D.29889;
  int D.29896;
  unsigned char D.29898;
  unsigned char D.29899;
  int D.29900;
  unsigned char D.29901;
  unsigned char D.29902;
  unsigned int num.28;
  unsigned int D.29904;
  struct MonoInst * * D.29905;
  unsigned int D.29906;
  struct MonoMethodVar * D.29907;
  unsigned int num.29;
  int D.29911;
  int iftmp.30;
  struct MonoType * D.29920;
  unsigned char D.29921;
  struct MonoType * D.29923;
  unsigned char D.29924;
  unsigned char D.29926;
  unsigned char D.29927;
  int iftmp.31;
  struct MonoType * D.29934;
  unsigned char D.29935;
  struct MonoType * D.29937;
  unsigned char D.29938;
  unsigned int D.29941;
  int D.29944;
  int D.29945;
  int D.29946;
  int D.29947;
  unsigned int D.29950;
  unsigned int D.29951;
  int D.29958;
  struct MonoInst * D.29959;
  int D.29960;
  int D.29961;
  struct MonoClass * D.29964;
  struct MonoType * D.29965;
  struct MonoType * D.29966;
  struct MonoClass * D.29967;
  struct MonoClass * D.29970;
  unsigned int D.29971;
  char * D.29974;
  struct MonoInst * D.29975;
  struct MonoInst * inst;
  int num;
  gboolean regpair;

  D.29848 = cfg->num_varinfo;
  num = (int) D.29848;
  type = mini_replace_type (type);
  D.29849 = num + 1;
  D.29850 = (unsigned int) D.29849;
  D.29851 = cfg->varinfo_count;
  if (D.29850 >= D.29851) goto <D.29852>; else goto <D.29853>;
  <D.29852>:
  {
    int orig_count;

    D.29851 = cfg->varinfo_count;
    orig_count = (int) D.29851;
    D.29851 = cfg->varinfo_count;
    if (D.29851 != 0) goto <D.29855>; else goto <D.29856>;
    <D.29855>:
    D.29851 = cfg->varinfo_count;
    iftmp.25 = D.29851 * 2;
    goto <D.29857>;
    <D.29856>:
    iftmp.25 = 64;
    <D.29857>:
    cfg->varinfo_count = iftmp.25;
    D.29858 = cfg->varinfo;
    D.29851 = cfg->varinfo_count;
    D.29859 = D.29851 * 4;
    D.29860 = monoeg_realloc (D.29858, D.29859);
    cfg->varinfo = D.29860;
    D.29861 = cfg->vars;
    D.29851 = cfg->varinfo_count;
    D.29862 = D.29851 * 56;
    D.29863 = monoeg_realloc (D.29861, D.29862);
    cfg->vars = D.29863;
    D.29861 = cfg->vars;
    orig_count.26 = (unsigned int) orig_count;
    D.29865 = orig_count.26 * 56;
    D.29866 = D.29861 + D.29865;
    D.29851 = cfg->varinfo_count;
    orig_count.27 = (unsigned int) orig_count;
    D.29868 = D.29851 - orig_count.27;
    D.29869 = D.29868 * 56;
    memset (D.29866, 0, D.29869);
  }
  <D.29853>:
  D.29870 = cfg->stat_allocate_var;
  D.29871 = D.29870 + 1;
  cfg->stat_allocate_var = D.29871;
  D.29872 = cfg->mempool;
  inst = mono_mempool_alloc (D.29872, 56);
  inst->data.op[1].const_val = 0;
  D.29873 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.29873;
  inst->prev = 0B;
  D.29874 = inst->prev;
  inst->next = D.29874;
  D.29875 = (short unsigned int) opcode;
  inst->opcode = D.29875;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.29876 = inst->sreg3;
  inst->sreg2 = D.29876;
  D.29877 = inst->sreg2;
  inst->sreg1 = D.29877;
  D.29878 = cfg->ip;
  inst->cil_code = D.29878;
  inst->data.op[0].const_val = num;
  inst->data.op[1].vtype = type;
  D.29879 = mono_class_from_mono_type (type);
  inst->klass = D.29879;
  type_to_eval_stack_type (cfg, type, inst);
  inst->backend.is_pinvoke = 0;
  inst->dreg = vreg;
  D.29880 = inst->klass;
  D.29881 = D.29880->exception_type;
  if (D.29881 != 0) goto <D.29882>; else goto <D.29883>;
  <D.29882>:
  mono_cfg_set_exception (cfg, 7);
  <D.29883>:
  D.29884 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.29885 = D.29884 & 128;
  if (D.29885 != 0) goto <D.29886>; else goto <D.29887>;
  <D.29886>:
  D.29888 = BIT_FIELD_REF <*type, 8, 56>;
  D.29889 = D.29888 & 64;
  if (D.29889 != 0) goto <D.29890>; else goto <D.29891>;
  <D.29890>:
  mono_mark_vreg_as_mp (cfg, vreg);
  goto <D.29892>;
  <D.29891>:
  {
    struct MonoType * t;

    t = mini_replace_type (type);
    D.29896 = mono_type_is_struct (t);
    if (D.29896 != 0) goto <D.29897>; else goto <D.29893>;
    <D.29897>:
    D.29880 = inst->klass;
    D.29898 = BIT_FIELD_REF <*D.29880, 8, 184>;
    D.29899 = D.29898 & 8;
    if (D.29899 != 0) goto <D.29894>; else goto <D.29893>;
    <D.29893>:
    D.29900 = mini_type_is_reference (cfg, t);
    if (D.29900 != 0) goto <D.29894>; else goto <D.29895>;
    <D.29894>:
    D.29901 = inst->flags;
    D.29902 = D.29901 | 128;
    inst->flags = D.29902;
    mono_mark_vreg_as_ref (cfg, vreg);
    <D.29895>:
  }
  <D.29892>:
  <D.29887>:
  D.29858 = cfg->varinfo;
  num.28 = (unsigned int) num;
  D.29904 = num.28 * 4;
  D.29905 = D.29858 + D.29904;
  *D.29905 = inst;
  D.29861 = cfg->vars;
  num.28 = (unsigned int) num;
  D.29906 = num.28 * 56;
  D.29907 = D.29861 + D.29906;
  D.29907->range.first_use.pos.bid = 65535;
  D.29861 = cfg->vars;
  num.28 = (unsigned int) num;
  D.29906 = num.28 * 56;
  D.29907 = D.29861 + D.29906;
  D.29907->reg = -1;
  D.29861 = cfg->vars;
  num.28 = (unsigned int) num;
  D.29906 = num.28 * 56;
  D.29907 = D.29861 + D.29906;
  num.29 = (unsigned int) num;
  D.29907->idx = num.29;
  D.29861 = cfg->vars;
  num.28 = (unsigned int) num;
  D.29906 = num.28 * 56;
  D.29907 = D.29861 + D.29906;
  D.29907->vreg = vreg;
  if (vreg != -1) goto <D.29909>; else goto <D.29910>;
  <D.29909>:
  set_vreg_to_inst (cfg, vreg, inst);
  <D.29910>:
  D.29911 = mono_arch_is_soft_float ();
  if (D.29911 != 0) goto <D.29912>; else goto <D.29913>;
  <D.29912>:
  D.29888 = BIT_FIELD_REF <*type, 8, 56>;
  D.29889 = D.29888 & 64;
  if (D.29889 == 0) goto <D.29919>; else goto <D.29915>;
  <D.29919>:
  D.29920 = mono_type_get_underlying_type (type);
  D.29921 = D.29920->type;
  if (D.29921 == 10) goto <D.29916>; else goto <D.29922>;
  <D.29922>:
  D.29923 = mono_type_get_underlying_type (type);
  D.29924 = D.29923->type;
  if (D.29924 == 11) goto <D.29916>; else goto <D.29915>;
  <D.29915>:
  D.29888 = BIT_FIELD_REF <*type, 8, 56>;
  D.29889 = D.29888 & 64;
  if (D.29889 == 0) goto <D.29925>; else goto <D.29917>;
  <D.29925>:
  D.29926 = type->type;
  D.29927 = D.29926 + 244;
  if (D.29927 <= 1) goto <D.29916>; else goto <D.29917>;
  <D.29916>:
  iftmp.30 = 1;
  goto <D.29918>;
  <D.29917>:
  iftmp.30 = 0;
  <D.29918>:
  regpair = iftmp.30;
  goto <D.29928>;
  <D.29913>:
  D.29888 = BIT_FIELD_REF <*type, 8, 56>;
  D.29889 = D.29888 & 64;
  if (D.29889 == 0) goto <D.29933>; else goto <D.29930>;
  <D.29933>:
  D.29934 = mono_type_get_underlying_type (type);
  D.29935 = D.29934->type;
  if (D.29935 == 10) goto <D.29931>; else goto <D.29936>;
  <D.29936>:
  D.29937 = mono_type_get_underlying_type (type);
  D.29938 = D.29937->type;
  if (D.29938 == 11) goto <D.29931>; else goto <D.29930>;
  <D.29931>:
  iftmp.31 = 1;
  goto <D.29932>;
  <D.29930>:
  iftmp.31 = 0;
  <D.29932>:
  regpair = iftmp.31;
  <D.29928>:
  if (regpair != 0) goto <D.29939>; else goto <D.29940>;
  <D.29939>:
  {
    struct MonoInst * tree;

    D.29941 = cfg->verbose_level;
    if (D.29941 > 3) goto <D.29942>; else goto <D.29943>;
    <D.29942>:
    D.29944 = inst->dreg;
    D.29944 = inst->dreg;
    D.29945 = D.29944 + 1;
    D.29944 = inst->dreg;
    D.29946 = D.29944 + 2;
    printf ("  Create LVAR R%d (R%d, R%d)\n", D.29944, D.29945, D.29946);
    <D.29943>:
    D.29947 = mono_arch_is_soft_float ();
    if (D.29947 != 0) goto <D.29948>; else goto <D.29949>;
    <D.29948>:
    D.29950 = cfg->opt;
    D.29951 = D.29950 & 2097152;
    if (D.29951 != 0) goto <D.29952>; else goto <D.29953>;
    <D.29952>:
    D.29888 = BIT_FIELD_REF <*type, 8, 56>;
    D.29889 = D.29888 & 64;
    if (D.29889 == 0) goto <D.29954>; else goto <D.29955>;
    <D.29954>:
    D.29926 = type->type;
    D.29927 = D.29926 + 244;
    if (D.29927 <= 1) goto <D.29956>; else goto <D.29957>;
    <D.29956>:
    inst->flags = 4;
    <D.29957>:
    <D.29955>:
    <D.29953>:
    <D.29949>:
    D.29872 = cfg->mempool;
    tree = mono_mempool_alloc (D.29872, 56);
    tree->data.op[1].const_val = 0;
    D.29958 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.29958;
    tree->prev = 0B;
    D.29959 = tree->prev;
    tree->next = D.29959;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.29960 = tree->sreg3;
    tree->sreg2 = D.29960;
    D.29961 = tree->sreg2;
    tree->sreg1 = D.29961;
    D.29878 = cfg->ip;
    tree->cil_code = D.29878;
    D.29944 = inst->dreg;
    D.29945 = D.29944 + 1;
    tree->dreg = D.29945;
    D.29950 = cfg->opt;
    D.29951 = D.29950 & 2097152;
    if (D.29951 != 0) goto <D.29962>; else goto <D.29963>;
    <D.29962>:
    tree->flags = 4;
    <D.29963>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.29964 = mono_defaults.int32_class;
    D.29965 = &D.29964->byval_arg;
    tree->data.op[1].vtype = D.29965;
    D.29966 = tree->data.op[1].vtype;
    D.29967 = mono_class_from_mono_type (D.29966);
    tree->klass = D.29967;
    D.29944 = inst->dreg;
    D.29945 = D.29944 + 1;
    set_vreg_to_inst (cfg, D.29945, tree);
    D.29872 = cfg->mempool;
    tree = mono_mempool_alloc (D.29872, 56);
    tree->data.op[1].const_val = 0;
    D.29958 = tree->data.op[1].const_val;
    tree->data.op[0].const_val = D.29958;
    tree->prev = 0B;
    D.29959 = tree->prev;
    tree->next = D.29959;
    tree->opcode = 329;
    tree->flags = 0;
    tree->type = 0;
    tree->dreg = -1;
    tree->sreg3 = -1;
    D.29960 = tree->sreg3;
    tree->sreg2 = D.29960;
    D.29961 = tree->sreg2;
    tree->sreg1 = D.29961;
    D.29878 = cfg->ip;
    tree->cil_code = D.29878;
    D.29944 = inst->dreg;
    D.29946 = D.29944 + 2;
    tree->dreg = D.29946;
    D.29950 = cfg->opt;
    D.29951 = D.29950 & 2097152;
    if (D.29951 != 0) goto <D.29968>; else goto <D.29969>;
    <D.29968>:
    tree->flags = 4;
    <D.29969>:
    tree->data.op[0].const_val = num;
    tree->type = 1;
    D.29964 = mono_defaults.int32_class;
    D.29965 = &D.29964->byval_arg;
    tree->data.op[1].vtype = D.29965;
    D.29966 = tree->data.op[1].vtype;
    D.29970 = mono_class_from_mono_type (D.29966);
    tree->klass = D.29970;
    D.29944 = inst->dreg;
    D.29946 = D.29944 + 2;
    set_vreg_to_inst (cfg, D.29946, tree);
  }
  <D.29940>:
  D.29848 = cfg->num_varinfo;
  D.29971 = D.29848 + 1;
  cfg->num_varinfo = D.29971;
  D.29941 = cfg->verbose_level;
  if (D.29941 > 2) goto <D.29972>; else goto <D.29973>;
  <D.29972>:
  D.29974 = mono_type_get_name (type);
  monoeg_g_print ("created temp %d (R%d) of type %s\n", num, vreg, D.29974);
  <D.29973>:
  D.29975 = inst;
  return D.29975;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.29979;
  int D.29984;
  void * D.29986;
  unsigned int D.29987;

  D.29979 = __builtin_constant_p (__len);
  if (D.29979 != 0) goto <D.29980>; else goto <D.29981>;
  <D.29980>:
  if (__len == 0) goto <D.29982>; else goto <D.29983>;
  <D.29982>:
  D.29984 = __builtin_constant_p (__ch);
  if (D.29984 == 0) goto <D.29977>; else goto <D.29985>;
  <D.29985>:
  if (__ch != 0) goto <D.29977>; else goto <D.29978>;
  <D.29977>:
  __warn_memset_zero_len ();
  D.29986 = __dest;
  return D.29986;
  <D.29978>:
  <D.29983>:
  <D.29981>:
  D.29987 = __builtin_object_size (__dest, 0);
  D.29986 = __builtin___memset_chk (__dest, __ch, __len, D.29987);
  return D.29986;
}


mono_arch_is_soft_float ()
{
  gboolean D.29989;

  D.29989 = 0;
  return D.29989;
}


set_vreg_to_inst (struct MonoCompile * cfg, int vreg, struct MonoInst * inst)
{
  unsigned int vreg.32;
  unsigned int D.29992;
  guint32 iftmp.33;
  struct MonoMemPool * D.29999;
  unsigned int D.30000;
  void * D.30001;
  struct MonoInst * * D.30004;
  unsigned int size.34;
  unsigned int D.30006;
  unsigned int vreg.35;
  unsigned int D.30008;
  struct MonoInst * * D.30009;

  vreg.32 = (unsigned int) vreg;
  D.29992 = cfg->vreg_to_inst_len;
  if (vreg.32 >= D.29992) goto <D.29993>; else goto <D.29994>;
  <D.29993>:
  {
    struct MonoInst * * tmp;
    int size;

    tmp = cfg->vreg_to_inst;
    D.29992 = cfg->vreg_to_inst_len;
    size = (int) D.29992;
    goto <D.27558>;
    <D.27557>:
    D.29992 = cfg->vreg_to_inst_len;
    if (D.29992 != 0) goto <D.29996>; else goto <D.29997>;
    <D.29996>:
    D.29992 = cfg->vreg_to_inst_len;
    iftmp.33 = D.29992 * 2;
    goto <D.29998>;
    <D.29997>:
    iftmp.33 = 32;
    <D.29998>:
    cfg->vreg_to_inst_len = iftmp.33;
    <D.27558>:
    vreg.32 = (unsigned int) vreg;
    D.29992 = cfg->vreg_to_inst_len;
    if (vreg.32 >= D.29992) goto <D.27557>; else goto <D.27559>;
    <D.27559>:
    D.29999 = cfg->mempool;
    D.29992 = cfg->vreg_to_inst_len;
    D.30000 = D.29992 * 4;
    D.30001 = mono_mempool_alloc0 (D.29999, D.30000);
    cfg->vreg_to_inst = D.30001;
    if (size != 0) goto <D.30002>; else goto <D.30003>;
    <D.30002>:
    D.30004 = cfg->vreg_to_inst;
    size.34 = (unsigned int) size;
    D.30006 = size.34 * 4;
    memcpy (D.30004, tmp, D.30006);
    <D.30003>:
  }
  <D.29994>:
  D.30004 = cfg->vreg_to_inst;
  vreg.35 = (unsigned int) vreg;
  D.30008 = vreg.35 * 4;
  D.30009 = D.30004 + D.30008;
  *D.30009 = inst;
}


mono_compile_create_var (struct MonoCompile * cfg, struct MonoType * type, int opcode)
{
  unsigned char D.30013;
  unsigned char D.30014;
  struct MonoType * D.30016;
  unsigned char D.30017;
  struct MonoType * D.30019;
  unsigned char D.30020;
  unsigned int D.30021;
  int D.30024;
  unsigned char D.30027;
  unsigned char D.30028;
  unsigned int D.30030;
  unsigned int D.30031;
  struct MonoInst * D.30032;
  int dreg;

  type = mini_replace_type (type);
  D.30013 = BIT_FIELD_REF <*type, 8, 56>;
  D.30014 = D.30013 & 64;
  if (D.30014 == 0) goto <D.30015>; else goto <D.30010>;
  <D.30015>:
  D.30016 = mono_type_get_underlying_type (type);
  D.30017 = D.30016->type;
  if (D.30017 == 10) goto <D.30011>; else goto <D.30018>;
  <D.30018>:
  D.30019 = mono_type_get_underlying_type (type);
  D.30020 = D.30019->type;
  if (D.30020 == 11) goto <D.30011>; else goto <D.30010>;
  <D.30011>:
  D.30021 = mono_alloc_dreg (cfg, 2);
  dreg = (int) D.30021;
  goto <D.30012>;
  <D.30010>:
  D.30024 = mono_arch_is_soft_float ();
  if (D.30024 != 0) goto <D.30025>; else goto <D.30022>;
  <D.30025>:
  D.30013 = BIT_FIELD_REF <*type, 8, 56>;
  D.30014 = D.30013 & 64;
  if (D.30014 == 0) goto <D.30026>; else goto <D.30022>;
  <D.30026>:
  D.30027 = type->type;
  D.30028 = D.30027 + 244;
  if (D.30028 <= 1) goto <D.30029>; else goto <D.30022>;
  <D.30029>:
  D.30030 = mono_alloc_dreg (cfg, 4);
  dreg = (int) D.30030;
  goto <D.30023>;
  <D.30022>:
  D.30031 = mono_alloc_preg (cfg);
  dreg = (int) D.30031;
  <D.30023>:
  <D.30012>:
  D.30032 = mono_compile_create_var_for_vreg (cfg, type, opcode, dreg);
  return D.30032;
}


mono_compile_make_var_load (struct MonoCompile * cfg, struct MonoInst * dest, gssize var_index)
{
  struct MonoInst * * D.30034;
  unsigned int var_index.36;
  unsigned int D.30036;
  struct MonoInst * * D.30037;
  struct MonoInst * D.30038;
  struct MonoInst * D.30039;
  struct MonoType * D.30040;
  unsigned int D.30041;
  short unsigned int D.30042;
  struct MonoClass * D.30043;

  memset (dest, 0, 56);
  D.30034 = cfg->varinfo;
  var_index.36 = (unsigned int) var_index;
  D.30036 = var_index.36 * 4;
  D.30037 = D.30034 + D.30036;
  D.30038 = *D.30037;
  dest->data.op[0].src = D.30038;
  D.30039 = dest->data.op[0].src;
  D.30040 = D.30039->data.op[1].vtype;
  D.30041 = mini_type_to_ldind (cfg, D.30040);
  D.30042 = (short unsigned int) D.30041;
  dest->opcode = D.30042;
  D.30039 = dest->data.op[0].src;
  D.30040 = D.30039->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.30040, dest);
  D.30039 = dest->data.op[0].src;
  D.30043 = D.30039->klass;
  dest->klass = D.30043;
}


mini_type_to_ldind (struct MonoCompile * cfg, struct MonoType * type)
{
  struct MonoGenericSharingContext * D.30044;
  unsigned char D.30047;
  unsigned char D.30048;
  unsigned char D.30051;
  _Bool D.30052;
  _Bool D.30053;
  _Bool D.30054;
  int D.30057;
  guint D.30060;

  D.30044 = cfg->generic_sharing_context;
  if (D.30044 != 0B) goto <D.30045>; else goto <D.30046>;
  <D.30045>:
  D.30047 = BIT_FIELD_REF <*type, 8, 56>;
  D.30048 = D.30047 & 64;
  if (D.30048 == 0) goto <D.30049>; else goto <D.30050>;
  <D.30049>:
  D.30051 = type->type;
  D.30052 = D.30051 == 19;
  D.30053 = D.30051 == 30;
  D.30054 = D.30052 | D.30053;
  if (D.30054 != 0) goto <D.30055>; else goto <D.30056>;
  <D.30055>:
  D.30057 = mini_type_var_is_vt (cfg, type);
  if (D.30057 != 0) goto <D.30058>; else goto <D.30059>;
  <D.30058>:
  D.30060 = 113;
  return D.30060;
  <D.30059>:
  D.30060 = 80;
  return D.30060;
  <D.30056>:
  <D.30050>:
  <D.30046>:
  D.30060 = mono_type_to_ldind (type);
  return D.30060;
}


mono_mark_vreg_as_ref (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.37;
  unsigned int D.30063;
  guint32 iftmp.38;
  struct MonoMemPool * D.30070;
  unsigned int D.30071;
  void * D.30072;
  gboolean * D.30075;
  unsigned int size.39;
  unsigned int D.30077;
  unsigned int vreg.40;
  unsigned int D.30079;
  gboolean * D.30080;

  vreg.37 = (unsigned int) vreg;
  D.30063 = cfg->vreg_is_ref_len;
  if (vreg.37 >= D.30063) goto <D.30064>; else goto <D.30065>;
  <D.30064>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_ref;
    D.30063 = cfg->vreg_is_ref_len;
    size = (int) D.30063;
    goto <D.27590>;
    <D.27589>:
    D.30063 = cfg->vreg_is_ref_len;
    if (D.30063 != 0) goto <D.30067>; else goto <D.30068>;
    <D.30067>:
    D.30063 = cfg->vreg_is_ref_len;
    iftmp.38 = D.30063 * 2;
    goto <D.30069>;
    <D.30068>:
    iftmp.38 = 32;
    <D.30069>:
    cfg->vreg_is_ref_len = iftmp.38;
    <D.27590>:
    vreg.37 = (unsigned int) vreg;
    D.30063 = cfg->vreg_is_ref_len;
    if (vreg.37 >= D.30063) goto <D.27589>; else goto <D.27591>;
    <D.27591>:
    D.30070 = cfg->mempool;
    D.30063 = cfg->vreg_is_ref_len;
    D.30071 = D.30063 * 4;
    D.30072 = mono_mempool_alloc0 (D.30070, D.30071);
    cfg->vreg_is_ref = D.30072;
    if (size != 0) goto <D.30073>; else goto <D.30074>;
    <D.30073>:
    D.30075 = cfg->vreg_is_ref;
    size.39 = (unsigned int) size;
    D.30077 = size.39 * 4;
    memcpy (D.30075, tmp, D.30077);
    <D.30074>:
  }
  <D.30065>:
  D.30075 = cfg->vreg_is_ref;
  vreg.40 = (unsigned int) vreg;
  D.30079 = vreg.40 * 4;
  D.30080 = D.30075 + D.30079;
  *D.30080 = 1;
}


mono_mark_vreg_as_mp (struct MonoCompile * cfg, int vreg)
{
  unsigned int vreg.41;
  unsigned int D.30082;
  guint32 iftmp.42;
  struct MonoMemPool * D.30089;
  unsigned int D.30090;
  void * D.30091;
  gboolean * D.30094;
  unsigned int size.43;
  unsigned int D.30096;
  unsigned int vreg.44;
  unsigned int D.30098;
  gboolean * D.30099;

  vreg.41 = (unsigned int) vreg;
  D.30082 = cfg->vreg_is_mp_len;
  if (vreg.41 >= D.30082) goto <D.30083>; else goto <D.30084>;
  <D.30083>:
  {
    gboolean * tmp;
    int size;

    tmp = cfg->vreg_is_mp;
    D.30082 = cfg->vreg_is_mp_len;
    size = (int) D.30082;
    goto <D.27599>;
    <D.27598>:
    D.30082 = cfg->vreg_is_mp_len;
    if (D.30082 != 0) goto <D.30086>; else goto <D.30087>;
    <D.30086>:
    D.30082 = cfg->vreg_is_mp_len;
    iftmp.42 = D.30082 * 2;
    goto <D.30088>;
    <D.30087>:
    iftmp.42 = 32;
    <D.30088>:
    cfg->vreg_is_mp_len = iftmp.42;
    <D.27599>:
    vreg.41 = (unsigned int) vreg;
    D.30082 = cfg->vreg_is_mp_len;
    if (vreg.41 >= D.30082) goto <D.27598>; else goto <D.27600>;
    <D.27600>:
    D.30089 = cfg->mempool;
    D.30082 = cfg->vreg_is_mp_len;
    D.30090 = D.30082 * 4;
    D.30091 = mono_mempool_alloc0 (D.30089, D.30090);
    cfg->vreg_is_mp = D.30091;
    if (size != 0) goto <D.30092>; else goto <D.30093>;
    <D.30092>:
    D.30094 = cfg->vreg_is_mp;
    size.43 = (unsigned int) size;
    D.30096 = size.43 * 4;
    memcpy (D.30094, tmp, D.30096);
    <D.30093>:
  }
  <D.30084>:
  D.30094 = cfg->vreg_is_mp;
  vreg.44 = (unsigned int) vreg;
  D.30098 = vreg.44 * 4;
  D.30099 = D.30094 + D.30098;
  *D.30099 = 1;
}


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

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


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.30102;
  int D.30103;
  struct MonoType * D.30104;
  struct MonoClass * D.30105;
  struct MonoClass * D.30106;
  struct MonoClass * D.30107;
  struct MonoClass * D.30108;
  struct MonoClass * D.30109;
  struct MonoClass * D.30112;
  unsigned char D.30115;
  unsigned char D.30116;

  D.30102 = ins->type;
  D.30103 = (int) D.30102;
  switch (D.30103) <default: <D.27611>, case 1: <D.27604>, case 2: <D.27605>, case 3: <D.27606>, case 4: <D.27607>, case 5: <D.27608>, case 6: <D.27609>, case 7: <D.27610>>
  <D.27604>:
  D.30105 = mono_defaults.int32_class;
  D.30104 = &D.30105->byval_arg;
  return D.30104;
  <D.27605>:
  D.30106 = mono_defaults.int64_class;
  D.30104 = &D.30106->byval_arg;
  return D.30104;
  <D.27606>:
  D.30107 = mono_defaults.int_class;
  D.30104 = &D.30107->byval_arg;
  return D.30104;
  <D.27607>:
  D.30108 = mono_defaults.double_class;
  D.30104 = &D.30108->byval_arg;
  return D.30104;
  <D.27608>:
  D.30109 = ins->klass;
  if (D.30109 != 0B) goto <D.30110>; else goto <D.30111>;
  <D.30110>:
  D.30109 = ins->klass;
  D.30104 = &D.30109->this_arg;
  return D.30104;
  <D.30111>:
  D.30112 = mono_defaults.object_class;
  D.30104 = &D.30112->this_arg;
  return D.30104;
  <D.27609>:
  D.30109 = ins->klass;
  if (D.30109 != 0B) goto <D.30113>; else goto <D.30114>;
  <D.30113>:
  D.30109 = ins->klass;
  D.30115 = BIT_FIELD_REF <*D.30109, 8, 160>;
  D.30116 = D.30115 & 8;
  if (D.30116 == 0) goto <D.30117>; else goto <D.30118>;
  <D.30117>:
  D.30109 = ins->klass;
  D.30104 = &D.30109->byval_arg;
  return D.30104;
  <D.30118>:
  <D.30114>:
  D.30112 = mono_defaults.object_class;
  D.30104 = &D.30112->byval_arg;
  return D.30104;
  <D.27610>:
  D.30109 = ins->klass;
  D.30104 = &D.30109->byval_arg;
  return D.30104;
  <D.27611>:
  D.30102 = ins->type;
  D.30103 = (int) D.30102;
  monoeg_g_log (0B, 4, "stack type %d to montype not handled\n", D.30103);
  <D.27612>:
  goto <D.27612>;
  D.30104 = 0B;
  return D.30104;
}


mono_add_ins_to_end (struct MonoBasicBlock * bb, struct MonoInst * inst)
{
  struct MonoInst * D.30120;
  struct MonoInst * D.30123;
  short unsigned int D.30127;
  int D.30128;
  short unsigned int D.30132;
  short unsigned int D.30133;
  _Bool D.30134;
  short unsigned int D.30135;
  _Bool D.30136;
  _Bool D.30137;
  short unsigned int D.30139;
  struct MonoInst * D.30142;
  short unsigned int D.30145;
  unsigned int opcode.45;
  unsigned int D.30150;
  _Bool D.30151;
  _Bool D.30152;
  _Bool D.30153;
  _Bool D.30155;
  _Bool D.30156;
  _Bool D.30157;
  _Bool D.30159;
  _Bool D.30160;
  _Bool D.30161;
  struct MonoInst * D.30163;
  short unsigned int D.30164;
  int opcode;

  D.30120 = bb->code;
  if (D.30120 == 0B) goto <D.30121>; else goto <D.30122>;
  <D.30121>:
  D.30123 = bb->last_ins;
  if (D.30123 != 0B) goto <D.30124>; else goto <D.30125>;
  <D.30124>:
  D.30123 = bb->last_ins;
  D.30123->next = inst;
  D.30123 = bb->last_ins;
  inst->prev = D.30123;
  bb->last_ins = inst;
  goto <D.30126>;
  <D.30125>:
  bb->last_ins = inst;
  D.30123 = bb->last_ins;
  bb->code = D.30123;
  <D.30126>:
  return;
  <D.30122>:
  D.30123 = bb->last_ins;
  D.30127 = D.30123->opcode;
  D.30128 = (int) D.30127;
  switch (D.30128) <default: <D.27635>, case 59: <D.27623>, case 60: <D.27624>, case 61: <D.27625>, case 62: <D.27626>, case 63: <D.27627>, case 64: <D.27628>, case 65: <D.27629>, case 66: <D.27630>, case 67: <D.27631>, case 68: <D.27632>, case 370: <D.27633>, case 442: <D.27621>, case 759: <D.27622>>
  <D.27621>:
  <D.27622>:
  <D.27623>:
  <D.27624>:
  <D.27625>:
  <D.27626>:
  <D.27627>:
  <D.27628>:
  <D.27629>:
  <D.27630>:
  <D.27631>:
  <D.27632>:
  <D.27633>:
  D.30123 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.30123, inst);
  goto <D.27634>;
  <D.27635>:
  D.30123 = bb->last_ins;
  D.30132 = D.30123->opcode;
  D.30133 = D.30132 + 64985;
  D.30134 = D.30133 <= 9;
  D.30135 = D.30132 + 64878;
  D.30136 = D.30135 <= 9;
  D.30137 = D.30134 | D.30136;
  if (D.30137 != 0) goto <D.30129>; else goto <D.30138>;
  <D.30138>:
  D.30123 = bb->last_ins;
  D.30127 = D.30123->opcode;
  D.30139 = D.30127 + 64888;
  if (D.30139 <= 9) goto <D.30129>; else goto <D.30130>;
  <D.30129>:
  D.30120 = bb->code;
  D.30123 = bb->last_ins;
  if (D.30120 == D.30123) goto <D.30140>; else goto <D.30141>;
  <D.30140>:
  D.30123 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.30123, inst);
  return;
  <D.30141>:
  D.30120 = bb->code;
  D.30142 = D.30120->next;
  D.30123 = bb->last_ins;
  if (D.30142 == D.30123) goto <D.30143>; else goto <D.30144>;
  <D.30143>:
  D.30120 = bb->code;
  D.30145 = D.30120->opcode;
  opcode = (int) D.30145;
  opcode.45 = (unsigned int) opcode;
  D.30150 = opcode.45 + 4294966974;
  D.30151 = D.30150 <= 1;
  D.30152 = opcode == 326;
  D.30153 = D.30151 | D.30152;
  if (D.30153 != 0) goto <D.30146>; else goto <D.30154>;
  <D.30154>:
  D.30155 = opcode == 327;
  D.30156 = opcode == 324;
  D.30157 = D.30155 | D.30156;
  if (D.30157 != 0) goto <D.30146>; else goto <D.30158>;
  <D.30158>:
  D.30159 = opcode == 325;
  D.30160 = opcode == 328;
  D.30161 = D.30159 | D.30160;
  if (D.30161 != 0) goto <D.30146>; else goto <D.30147>;
  <D.30146>:
  D.30120 = bb->code;
  mono_bblock_insert_before_ins (bb, D.30120, inst);
  goto <D.30148>;
  <D.30147>:
  D.30123 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.30123, inst);
  <D.30148>:
  goto <D.30162>;
  <D.30144>:
  D.30123 = bb->last_ins;
  D.30163 = D.30123->prev;
  D.30164 = D.30163->opcode;
  opcode = (int) D.30164;
  opcode.45 = (unsigned int) opcode;
  D.30150 = opcode.45 + 4294966974;
  D.30151 = D.30150 <= 1;
  D.30152 = opcode == 326;
  D.30153 = D.30151 | D.30152;
  if (D.30153 != 0) goto <D.30165>; else goto <D.30168>;
  <D.30168>:
  D.30155 = opcode == 327;
  D.30156 = opcode == 324;
  D.30157 = D.30155 | D.30156;
  if (D.30157 != 0) goto <D.30165>; else goto <D.30169>;
  <D.30169>:
  D.30159 = opcode == 325;
  D.30160 = opcode == 328;
  D.30161 = D.30159 | D.30160;
  if (D.30161 != 0) goto <D.30165>; else goto <D.30166>;
  <D.30165>:
  D.30123 = bb->last_ins;
  D.30163 = D.30123->prev;
  mono_bblock_insert_before_ins (bb, D.30163, inst);
  goto <D.30167>;
  <D.30166>:
  D.30123 = bb->last_ins;
  mono_bblock_insert_before_ins (bb, D.30123, inst);
  <D.30167>:
  <D.30162>:
  goto <D.30131>;
  <D.30130>:
  D.30123 = bb->last_ins;
  if (D.30123 != 0B) goto <D.30170>; else goto <D.30171>;
  <D.30170>:
  D.30123 = bb->last_ins;
  D.30123->next = inst;
  D.30123 = bb->last_ins;
  inst->prev = D.30123;
  bb->last_ins = inst;
  goto <D.30172>;
  <D.30171>:
  bb->last_ins = inst;
  D.30123 = bb->last_ins;
  bb->code = D.30123;
  <D.30172>:
  <D.30131>:
  goto <D.27634>;
  <D.27634>:
}


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

  D.30174 = cfg->mempool;
  ji = mono_mempool_alloc (D.30174, 20);
  D.30174 = cfg->mempool;
  table = mono_mempool_alloc (D.30174, 8);
  table->table = bbs;
  table->table_size = num_blocks;
  ji->ip.label = label;
  ji->type = 8;
  ji->data.table = table;
  D.30175 = cfg->patch_info;
  ji->next = D.30175;
  cfg->patch_info = ji;
}


mono_get_array_new_va_icall (int rank)
{
  _Bool D.30178;
  long int D.30179;
  long int D.30180;
  struct GHashTable * jit_icall_name_hash.46;
  _Bool D.30188;
  long int D.30189;
  long int D.30190;
  struct MonoJitICallInfo * D.30193;
  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.30176>; else goto <D.30177>;
        <D.30176>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30177>:
        D.30178 = ret != 0;
        D.30179 = (long int) D.30178;
        D.30180 = __builtin_expect (D.30179, 0);
        if (D.30180 != 0) goto <D.30181>; else goto <D.30182>;
        <D.30181>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1561, "ret == 0");
        <D.30182>:
      }
      info = mono_find_jit_icall_by_name (&icall_name);
      if (info == 0B) goto <D.30183>; else goto <D.30184>;
      <D.30183>:
      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.46 = jit_icall_name_hash;
      monoeg_g_hash_table_insert_replace (jit_icall_name_hash.46, name, name, 0);
      <D.30184>:
      {
        int ret;

        ret = pthread_mutex_unlock (&jit_mutex.mutex);
        if (ret != 0) goto <D.30186>; else goto <D.30187>;
        <D.30186>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30187>:
        D.30188 = ret != 0;
        D.30189 = (long int) D.30188;
        D.30190 = __builtin_expect (D.30189, 0);
        if (D.30190 != 0) goto <D.30191>; else goto <D.30192>;
        <D.30191>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1570, "ret == 0");
        <D.30192>:
      }
      D.30193 = info;
      return D.30193;
    }
  finally
    {
      icall_name = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.30196;
  unsigned int D.30197;

  D.30197 = __builtin_object_size (__s, 1);
  D.30196 = __builtin___sprintf_chk (__s, 1, D.30197, __fmt, __builtin_va_arg_pack ());
  return D.30196;
}


mono_get_array_new_va_signature (int arity)
{
  _Bool D.30201;
  long int D.30202;
  long int D.30203;
  struct GHashTable * sighash.47;
  struct GHashTable * sighash.48;
  const void * arity.49;
  _Bool D.30216;
  long int D.30217;
  long int D.30218;
  struct MonoMethodSignature * D.30221;
  struct MonoImage * D.30222;
  int D.30223;
  unsigned int D.30224;
  struct MonoClass * D.30227;
  struct MonoType * D.30228;
  int D.30229;
  struct MonoClass * D.30230;
  struct MonoType * D.30231;
  void * arity.50;
  _Bool D.30235;
  long int D.30236;
  long int D.30237;
  static struct GHashTable * sighash = 0B;
  struct MonoMethodSignature * res;
  int i;

  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30199>; else goto <D.30200>;
    <D.30199>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30200>:
    D.30201 = ret != 0;
    D.30202 = (long int) D.30201;
    D.30203 = __builtin_expect (D.30202, 0);
    if (D.30203 != 0) goto <D.30204>; else goto <D.30205>;
    <D.30204>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1518, "ret == 0");
    <D.30205>:
  }
  sighash.47 = sighash;
  if (sighash.47 == 0B) goto <D.30207>; else goto <D.30208>;
  <D.30207>:
  sighash.48 = monoeg_g_hash_table_new (0B, 0B);
  sighash = sighash.48;
  goto <D.30210>;
  <D.30208>:
  sighash.47 = sighash;
  arity.49 = (const void *) arity;
  res = monoeg_g_hash_table_lookup (sighash.47, arity.49);
  if (res != 0B) goto <D.30212>; else goto <D.30213>;
  <D.30212>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30214>; else goto <D.30215>;
    <D.30214>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30215>:
    D.30216 = ret != 0;
    D.30217 = (long int) D.30216;
    D.30218 = __builtin_expect (D.30217, 0);
    if (D.30218 != 0) goto <D.30219>; else goto <D.30220>;
    <D.30219>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1523, "ret == 0");
    <D.30220>:
  }
  D.30221 = res;
  return D.30221;
  <D.30213>:
  <D.30210>:
  D.30222 = mono_defaults.corlib;
  D.30223 = arity + 1;
  D.30224 = (unsigned int) D.30223;
  res = mono_metadata_signature_alloc (D.30222, D.30224);
  res->pinvoke = 1;
  if (0 != 0) goto <D.30225>; else goto <D.30226>;
  <D.30225>:
  res->call_convention = 5;
  <D.30226>:
  D.30227 = mono_defaults.int_class;
  D.30228 = &D.30227->byval_arg;
  res->params[0] = D.30228;
  i = 0;
  goto <D.27653>;
  <D.27652>:
  D.30229 = i + 1;
  D.30227 = mono_defaults.int_class;
  D.30228 = &D.30227->byval_arg;
  res->params[D.30229] = D.30228;
  i = i + 1;
  <D.27653>:
  if (i < arity) goto <D.27652>; else goto <D.27654>;
  <D.27654>:
  D.30230 = mono_defaults.object_class;
  D.30231 = &D.30230->byval_arg;
  res->ret = D.30231;
  sighash.47 = sighash;
  arity.50 = (void *) arity;
  monoeg_g_hash_table_insert_replace (sighash.47, arity.50, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.30233>; else goto <D.30234>;
    <D.30233>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30234>:
    D.30235 = ret != 0;
    D.30236 = (long int) D.30235;
    D.30237 = __builtin_expect (D.30236, 0);
    if (D.30237 != 0) goto <D.30238>; else goto <D.30239>;
    <D.30238>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1545, "ret == 0");
    <D.30239>:
  }
  D.30221 = res;
  return D.30221;
}


mini_class_is_system_array (struct MonoClass * klass)
{
  struct MonoClass * D.30241;
  struct MonoClass * D.30242;
  gboolean D.30245;

  D.30241 = klass->parent;
  D.30242 = mono_defaults.array_class;
  if (D.30241 == D.30242) goto <D.30243>; else goto <D.30244>;
  <D.30243>:
  D.30245 = 1;
  return D.30245;
  <D.30244>:
  D.30245 = 0;
  return D.30245;
}


mini_assembly_can_skip_verification (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoClass * D.30247;
  struct MonoImage * D.30248;
  unsigned char D.30249;
  unsigned char D.30250;
  _Bool D.30251;
  _Bool D.30252;
  _Bool D.30253;
  gboolean D.30256;
  unsigned char D.30259;
  struct MonoImage * D.30261;
  struct MonoImage * D.30262;
  int D.30263;
  struct MonoAssembly * assembly;

  D.30247 = method->klass;
  D.30248 = D.30247->image;
  assembly = D.30248->assembly;
  D.30249 = BIT_FIELD_REF <*method, 8, 160>;
  D.30250 = D.30249 & 124;
  D.30251 = D.30250 != 0;
  D.30252 = D.30250 != 68;
  D.30253 = D.30251 & D.30252;
  if (D.30253 != 0) goto <D.30254>; else goto <D.30255>;
  <D.30254>:
  D.30256 = 0;
  return D.30256;
  <D.30255>:
  D.30259 = assembly->in_gac;
  if (D.30259 != 0) goto <D.30257>; else goto <D.30260>;
  <D.30260>:
  D.30261 = assembly->image;
  D.30262 = mono_defaults.corlib;
  if (D.30261 == D.30262) goto <D.30257>; else goto <D.30258>;
  <D.30257>:
  D.30256 = 0;
  return D.30256;
  <D.30258>:
  D.30263 = mono_is_security_manager_active ();
  if (D.30263 != 0) goto <D.30264>; else goto <D.30265>;
  <D.30264>:
  D.30256 = 0;
  return D.30256;
  <D.30265>:
  D.30256 = mono_assembly_has_skip_verification (assembly);
  return D.30256;
}


mono_compile_is_broken (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  struct MonoClass * D.30267;
  struct MonoImage * D.30268;
  struct MonoAssembly * D.30269;
  unsigned char D.30270;
  unsigned char D.30271;
  unsigned char D.30272;
  gboolean D.30273;
  int iftmp.51;
  int D.30278;
  struct MonoMethod * method_definition;
  gboolean dont_verify;

  method_definition = method;
  D.30267 = method->klass;
  D.30268 = D.30267->image;
  D.30269 = D.30268->assembly;
  D.30270 = D.30269->corlib_internal;
  dont_verify = (gboolean) D.30270;
  goto <D.27697>;
  <D.27696>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method_definition;
    method_definition = imethod->declaring;
  }
  <D.27697>:
  D.30271 = BIT_FIELD_REF <*method_definition, 8, 168>;
  D.30272 = D.30271 & 16;
  if (D.30272 != 0) goto <D.27696>; else goto <D.27698>;
  <D.27698>:
  if (dont_verify == 0) goto <D.30277>; else goto <D.30275>;
  <D.30277>:
  D.30278 = mini_method_verify (cfg, method_definition, fail_compile);
  if (D.30278 != 0) goto <D.30279>; else goto <D.30275>;
  <D.30279>:
  iftmp.51 = 1;
  goto <D.30276>;
  <D.30275>:
  iftmp.51 = 0;
  <D.30276>:
  D.30273 = iftmp.51;
  return D.30273;
}


mini_method_verify (struct MonoCompile * cfg, struct MonoMethod * method, gboolean fail_compile)
{
  unsigned char D.30281;
  unsigned char D.30282;
  gboolean D.30285;
  int D.30286;
  int iftmp.52;
  int D.30293;
  struct MonoDomain * D.30295;
  int D.30296;
  <unnamed-unsigned:1> D.30297;
  int D.30298;
  unsigned char D.30303;
  unsigned int D.30304;
  <unnamed type> D.30310;
  signed char D.30315;
  unsigned int D.30316;
  char * D.30317;
  gchar * D.30318;
  gchar * D.30327;
  struct GSList * tmp;
  struct GSList * res;
  gboolean is_fulltrust;
  struct MonoLoaderError * error;

  D.30281 = BIT_FIELD_REF <*method, 8, 168>;
  D.30282 = D.30281 & 64;
  if (D.30282 != 0) goto <D.30283>; else goto <D.30284>;
  <D.30283>:
  D.30285 = 0;
  return D.30285;
  <D.30284>:
  D.30286 = mono_verifier_is_enabled_for_method (method);
  if (D.30286 == 0) goto <D.30287>; else goto <D.30288>;
  <D.30287>:
  D.30285 = 0;
  return D.30285;
  <D.30288>:
  D.30293 = mono_verifier_is_method_full_trust (method);
  if (D.30293 != 0) goto <D.30290>; else goto <D.30294>;
  <D.30294>:
  D.30295 = cfg->domain;
  D.30296 = mini_assembly_can_skip_verification (D.30295, method);
  if (D.30296 != 0) goto <D.30290>; else goto <D.30291>;
  <D.30290>:
  iftmp.52 = 1;
  goto <D.30292>;
  <D.30291>:
  iftmp.52 = 0;
  <D.30292>:
  is_fulltrust = iftmp.52;
  D.30297 = cfg->skip_visibility;
  D.30298 = (int) D.30297;
  res = mono_method_verify_with_current_settings (method, D.30298, is_fulltrust);
  error = mono_loader_get_last_error ();
  if (error != 0B) goto <D.30299>; else goto <D.30300>;
  <D.30299>:
  if (fail_compile != 0) goto <D.30301>; else goto <D.30302>;
  <D.30301>:
  D.30303 = error->exception_type;
  D.30304 = (unsigned int) D.30303;
  cfg->exception_type = D.30304;
  goto <D.30305>;
  <D.30302>:
  mono_loader_clear_error ();
  <D.30305>:
  if (res != 0B) goto <D.30306>; else goto <D.30307>;
  <D.30306>:
  mono_free_verify_list (res);
  <D.30307>:
  D.30285 = 1;
  return D.30285;
  <D.30300>:
  if (res != 0B) goto <D.30308>; else goto <D.30309>;
  <D.30308>:
  tmp = res;
  goto <D.27686>;
  <D.27685>:
  {
    struct MonoVerifyInfoExtended * info;

    info = tmp->data;
    D.30310 = info->info.status;
    if (D.30310 == 1) goto <D.30311>; else goto <D.30312>;
    <D.30311>:
    if (fail_compile != 0) goto <D.30313>; else goto <D.30314>;
    <D.30313>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.30315 = info->exception_type;
      D.30316 = (unsigned int) D.30315;
      cfg->exception_type = D.30316;
      D.30317 = info->info.message;
      D.30318 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.30317);
      cfg->exception_message = D.30318;
      monoeg_g_free (method_name);
    }
    <D.30314>:
    mono_free_verify_list (res);
    D.30285 = 1;
    return D.30285;
    <D.30312>:
    D.30310 = info->info.status;
    if (D.30310 == 8) goto <D.30321>; else goto <D.30322>;
    <D.30321>:
    if (is_fulltrust == 0) goto <D.30319>; else goto <D.30323>;
    <D.30323>:
    D.30315 = info->exception_type;
    if (D.30315 == 9) goto <D.30319>; else goto <D.30324>;
    <D.30324>:
    D.30315 = info->exception_type;
    if (D.30315 == 10) goto <D.30319>; else goto <D.30320>;
    <D.30319>:
    if (fail_compile != 0) goto <D.30325>; else goto <D.30326>;
    <D.30325>:
    {
      char * method_name;

      method_name = mono_method_full_name (method, 1);
      D.30315 = info->exception_type;
      D.30316 = (unsigned int) D.30315;
      cfg->exception_type = D.30316;
      D.30317 = info->info.message;
      D.30327 = monoeg_g_strdup_printf ("Error verifying %s: %s", method_name, D.30317);
      cfg->exception_message = D.30327;
      monoeg_g_free (method_name);
    }
    <D.30326>:
    mono_free_verify_list (res);
    D.30285 = 1;
    return D.30285;
    <D.30320>:
    <D.30322>:
  }
  tmp = tmp->next;
  <D.27686>:
  if (tmp != 0B) goto <D.27685>; else goto <D.27687>;
  <D.27687>:
  mono_free_verify_list (res);
  <D.30309>:
  method->verification_success = 1;
  D.30285 = 0;
  return D.30285;
}


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

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


mono_icall_get_wrapper_full (struct MonoJitICallInfo * callinfo, gboolean do_compile)
{
  const void * D.30331;
  const void * D.30334;
  const void * D.30335;
  union mono_mutex_t * D.30338;
  _Bool D.30341;
  long int D.30342;
  long int D.30343;
  _Bool D.30350;
  long int D.30351;
  long int D.30352;
  const char * D.30355;
  struct MonoMethodSignature * D.30356;
  const void * D.30357;
  int check_for_pending_exc.53;
  void * D.30362;
  _Bool D.30365;
  long int D.30366;
  long int D.30367;
  char * name;
  struct MonoMethod * wrapper;
  const void * trampoline;
  struct MonoDomain * domain;

  domain = mono_get_root_domain ();
  D.30331 = callinfo->wrapper;
  if (D.30331 != 0B) goto <D.30332>; else goto <D.30333>;
  <D.30332>:
  D.30334 = callinfo->wrapper;
  return D.30334;
  <D.30333>:
  D.30335 = callinfo->trampoline;
  if (D.30335 != 0B) goto <D.30336>; else goto <D.30337>;
  <D.30336>:
  D.30334 = callinfo->trampoline;
  return D.30334;
  <D.30337>:
  mono_loader_lock ();
  {
    int ret;

    D.30338 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30338);
    if (ret != 0) goto <D.30339>; else goto <D.30340>;
    <D.30339>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30340>:
    D.30341 = ret != 0;
    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", 1697, "ret == 0");
    <D.30345>:
  }
  D.30335 = callinfo->trampoline;
  if (D.30335 != 0B) goto <D.30346>; else goto <D.30347>;
  <D.30346>:
  {
    int ret;

    D.30338 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30338);
    if (ret != 0) goto <D.30348>; else goto <D.30349>;
    <D.30348>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30349>:
    D.30350 = ret != 0;
    D.30351 = (long int) D.30350;
    D.30352 = __builtin_expect (D.30351, 0);
    if (D.30352 != 0) goto <D.30353>; else goto <D.30354>;
    <D.30353>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1700, "ret == 0");
    <D.30354>:
  }
  mono_loader_unlock ();
  D.30334 = callinfo->trampoline;
  return D.30334;
  <D.30347>:
  D.30355 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.30355);
  D.30356 = callinfo->sig;
  D.30357 = callinfo->func;
  check_for_pending_exc.53 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.30356, name, D.30357, check_for_pending_exc.53);
  monoeg_g_free (name);
  if (do_compile != 0) goto <D.30359>; else goto <D.30360>;
  <D.30359>:
  trampoline = mono_compile_method (wrapper);
  goto <D.30361>;
  <D.30360>:
  D.30362 = mono_create_jit_trampoline_in_domain (domain, wrapper);
  trampoline = mono_create_ftnptr (domain, D.30362);
  <D.30361>:
  mono_register_jit_icall_wrapper (callinfo, trampoline);
  callinfo->trampoline = trampoline;
  {
    int ret;

    D.30338 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30338);
    if (ret != 0) goto <D.30363>; else goto <D.30364>;
    <D.30363>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30364>:
    D.30365 = ret != 0;
    D.30366 = (long int) D.30365;
    D.30367 = __builtin_expect (D.30366, 0);
    if (D.30367 != 0) goto <D.30368>; else goto <D.30369>;
    <D.30368>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1717, "ret == 0");
    <D.30369>:
  }
  mono_loader_unlock ();
  D.30334 = callinfo->trampoline;
  return D.30334;
}


mono_allocate_stack_slots (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  unsigned int D.30371;
  struct MonoMethodVar * D.30374;
  struct MonoLiveInterval * D.30375;
  gint32 * D.30378;
  struct MonoMemPool * D.30379;
  unsigned int D.30380;
  unsigned int i.54;
  unsigned int D.30382;
  gint32 * D.30383;
  unsigned int i.55;
  unsigned int D.30385;
  struct MonoInst * * D.30386;
  struct MonoInst * * D.30387;
  unsigned int D.30388;
  unsigned char D.30391;
  int D.30392;
  int D.30393;
  short unsigned int D.30395;
  unsigned int D.30397;
  unsigned int D.30398;
  struct MonoInst * * D.30399;
  struct MonoType * D.30400;
  int D.30401;
  int D.30404;
  int D.30409;
  int D.30411;
  unsigned char D.30413;
  struct MonoClass * D.30415;
  int ialign.56;
  unsigned int ialign.57;
  struct MonoClass * D.30418;
  unsigned char D.30419;
  unsigned char D.30424;
  unsigned char D.30425;
  unsigned char D.30428;
  unsigned char D.30429;
  int D.30433;
  int D.30434;
  unsigned int D.30437;
  unsigned int D.30438;
  struct MonoClass * D.30441;
  unsigned int D.30442;
  struct StackSlotInfo * D.30443;
  struct MonoClass * D.30444;
  _Bool D.30449;
  long int D.30450;
  long int D.30451;
  unsigned int nvtypes.58;
  unsigned int D.30455;
  struct StackSlotInfo * D.30456;
  unsigned char D.30457;
  unsigned char D.30460;
  unsigned int D.30465;
  unsigned int D.30466;
  struct GList * D.30469;
  unsigned int D.30470;
  unsigned int D.30471;
  struct GList * D.30473;
  struct GSList * D.30474;
  unsigned int D.30475;
  unsigned int D.30476;
  gint32 * D.30477;
  int D.30478;
  void * D.30479;
  struct GSList * D.30480;
  int D.30481;
  void * D.30486;
  struct GSList * D.30487;
  struct GList * D.30488;
  int count.59;
  int count.60;
  int D.30491;
  int D.30498;
  unsigned int align.61;
  unsigned int align.62;
  guint32 iftmp.63;
  struct MonoClass * D.30504;
  int D.30505;
  unsigned int D.30506;
  struct MonoClass * D.30509;
  int D.30510;
  unsigned int size.64;
  unsigned int D.30513;
  unsigned int D.30514;
  unsigned int D.30515;
  unsigned int D.30516;
  unsigned int offset.65;
  unsigned int D.30520;
  unsigned int D.30521;
  unsigned int D.30522;
  unsigned int D.30524;
  unsigned int D.30525;
  gint32 * D.30526;
  struct StackSlotInfo * D.30527;
  struct GList * D.30528;
  struct GList * D.30531;
  int D.30534;
  int D.30535;
  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.30371 = cfg->num_varinfo;
      if (D.30371 != 0) goto <D.30372>; else goto <D.30373>;
      <D.30372>:
      D.30374 = cfg->vars;
      D.30375 = D.30374->interval;
      if (D.30375 != 0B) goto <D.30376>; else goto <D.30377>;
      <D.30376>:
      D.30378 = mono_allocate_stack_slots2 (cfg, backward, stack_size, stack_align);
      return D.30378;
      <D.30377>:
      <D.30373>:
      D.30379 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.30379, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.30379 = cfg->mempool;
      D.30371 = cfg->num_varinfo;
      D.30380 = D.30371 * 4;
      offsets = mono_mempool_alloc (D.30379, D.30380);
      i = 0;
      goto <D.27832>;
      <D.27831>:
      i.54 = (unsigned int) i;
      D.30382 = i.54 * 4;
      D.30383 = offsets + D.30382;
      *D.30383 = -1;
      i = i + 1;
      <D.27832>:
      i.55 = (unsigned int) i;
      D.30371 = cfg->num_varinfo;
      if (i.55 < D.30371) goto <D.27831>; else goto <D.27833>;
      <D.27833>:
      D.30385 = cfg->locals_start;
      i = (int) D.30385;
      goto <D.27836>;
      <D.27835>:
      D.30386 = cfg->varinfo;
      i.54 = (unsigned int) i;
      D.30382 = i.54 * 4;
      D.30387 = D.30386 + D.30382;
      inst = *D.30387;
      D.30374 = cfg->vars;
      i.54 = (unsigned int) i;
      D.30388 = i.54 * 56;
      vmv = D.30374 + D.30388;
      D.30391 = inst->flags;
      D.30392 = (int) D.30391;
      D.30393 = D.30392 & 2;
      if (D.30393 != 0) goto <D.30389>; else goto <D.30394>;
      <D.30394>:
      D.30395 = inst->opcode;
      if (D.30395 == 366) goto <D.30389>; else goto <D.30396>;
      <D.30396>:
      D.30395 = inst->opcode;
      if (D.30395 == 367) goto <D.30389>; else goto <D.30390>;
      <D.30389>:
      // predicted unlikely by continue predictor.
      goto <D.27834>;
      <D.30390>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.27834>:
      i = i + 1;
      <D.27836>:
      i.55 = (unsigned int) i;
      D.30371 = cfg->num_varinfo;
      if (i.55 < D.30371) goto <D.27835>; else goto <D.27837>;
      <D.27837>:
      vars = mono_varlist_sort (cfg, vars, 0);
      offset = 0;
      *stack_align = 4;
      l = vars;
      goto <D.27864>;
      <D.27863>:
      vmv = l->data;
      D.30386 = cfg->varinfo;
      D.30397 = vmv->idx;
      D.30398 = D.30397 * 4;
      D.30399 = D.30386 + D.30398;
      inst = *D.30399;
      D.30400 = inst->data.op[1].vtype;
      t = mono_type_get_underlying_type (D.30400);
      D.30401 = cfg->gsharedvt;
      if (D.30401 != 0) goto <D.30402>; else goto <D.30403>;
      <D.30402>:
      D.30404 = mini_is_gsharedvt_variable_type (cfg, t);
      if (D.30404 != 0) goto <D.30405>; else goto <D.30406>;
      <D.30405>:
      // predicted unlikely by continue predictor.
      goto <D.27838>;
      <D.30406>:
      <D.30403>:
      D.30409 = inst->backend.is_pinvoke;
      if (D.30409 != 0) goto <D.30410>; else goto <D.30407>;
      <D.30410>:
      D.30411 = mono_type_is_struct (t);
      if (D.30411 != 0) goto <D.30412>; else goto <D.30407>;
      <D.30412>:
      D.30413 = t->type;
      if (D.30413 != 22) goto <D.30414>; else goto <D.30407>;
      <D.30414>:
      D.30415 = mono_class_from_mono_type (t);
      size = mono_class_native_size (D.30415, &align);
      goto <D.30408>;
      <D.30407>:
      {
        int ialign;

        try
          {
            size = mono_type_size (t, &ialign);
            ialign.56 = ialign;
            ialign.57 = (unsigned int) ialign.56;
            align = ialign.57;
            D.30418 = mono_class_from_mono_type (t);
            D.30419 = D.30418->exception_type;
            if (D.30419 != 0) goto <D.30420>; else goto <D.30421>;
            <D.30420>:
            mono_cfg_set_exception (cfg, 7);
            <D.30421>:
            if (0 != 0) goto <D.30422>; else goto <D.30423>;
            <D.30422>:
            align = 16;
            <D.30423>:
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.30408>:
      reuse_slot = 1;
      D.30424 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.30425 = D.30424 & 1;
      if (D.30425 != 0) goto <D.30426>; else goto <D.30427>;
      <D.30426>:
      reuse_slot = 0;
      <D.30427>:
      D.30428 = BIT_FIELD_REF <*t, 8, 56>;
      D.30429 = D.30428 & 64;
      if (D.30429 != 0) goto <D.30430>; else goto <D.30431>;
      <D.30430>:
      slot_info = scalar_stack_slots + 384;
      goto <D.30432>;
      <D.30431>:
      D.30413 = t->type;
      D.30433 = (int) D.30413;
      switch (D.30433) <default: <D.27857>, case 8: <D.27849>, case 14: <D.27854>, case 15: <D.27846>, case 17: <D.27842>, case 18: <D.27850>, case 19: <D.27855>, case 20: <D.27852>, case 21: <D.27840>, case 24: <D.27847>, case 25: <D.27848>, case 28: <D.27851>, case 29: <D.27853>, case 30: <D.27856>>
      <D.27840>:
      D.30434 = mono_type_generic_inst_is_valuetype (t);
      if (D.30434 == 0) goto <D.30435>; else goto <D.30436>;
      <D.30435>:
      D.30413 = t->type;
      D.30437 = (unsigned int) D.30413;
      D.30438 = D.30437 * 16;
      slot_info = scalar_stack_slots + D.30438;
      goto <D.27841>;
      <D.30436>:
      <D.27842>:
      if (vtype_stack_slots == 0B) goto <D.30439>; else goto <D.30440>;
      <D.30439>:
      D.30379 = cfg->mempool;
      vtype_stack_slots = mono_mempool_alloc0 (D.30379, 4096);
      <D.30440>:
      i = 0;
      goto <D.27845>;
      <D.27844>:
      D.30441 = t->data.klass;
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      D.30443 = vtype_stack_slots + D.30442;
      D.30444 = D.30443->vtype;
      if (D.30441 == D.30444) goto <D.27843>; else goto <D.30445>;
      <D.30445>:
      i = i + 1;
      <D.27845>:
      if (i < nvtypes) goto <D.27844>; else goto <D.27843>;
      <D.27843>:
      if (i < nvtypes) goto <D.30446>; else goto <D.30447>;
      <D.30446>:
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      slot_info = vtype_stack_slots + D.30442;
      goto <D.30448>;
      <D.30447>:
      D.30449 = nvtypes > 255;
      D.30450 = (long int) D.30449;
      D.30451 = __builtin_expect (D.30450, 0);
      if (D.30451 != 0) goto <D.30452>; else goto <D.30453>;
      <D.30452>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2176, "nvtypes < 256");
      <D.30453>:
      nvtypes.58 = (unsigned int) nvtypes;
      D.30455 = nvtypes.58 * 16;
      D.30456 = vtype_stack_slots + D.30455;
      D.30441 = t->data.klass;
      D.30456->vtype = D.30441;
      nvtypes.58 = (unsigned int) nvtypes;
      D.30455 = nvtypes.58 * 16;
      slot_info = vtype_stack_slots + D.30455;
      nvtypes = nvtypes + 1;
      <D.30448>:
      D.30424 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.30457 = D.30424 & 2;
      if (D.30457 != 0) goto <D.30458>; else goto <D.30459>;
      <D.30458>:
      reuse_slot = 0;
      <D.30459>:
      goto <D.27841>;
      <D.27846>:
      <D.27847>:
      <D.27848>:
      <D.27849>:
      D.30424 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.30460 = D.30424 & 4;
      if (D.30460 != 0) goto <D.30461>; else goto <D.30462>;
      <D.30461>:
      slot_info = scalar_stack_slots + 384;
      goto <D.27841>;
      <D.30462>:
      <D.27850>:
      <D.27851>:
      <D.27852>:
      <D.27853>:
      <D.27854>:
      slot_info = scalar_stack_slots + 288;
      D.30424 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.30457 = D.30424 & 2;
      if (D.30457 != 0) goto <D.30463>; else goto <D.30464>;
      <D.30463>:
      reuse_slot = 0;
      <D.30464>:
      goto <D.27841>;
      <D.27855>:
      <D.27856>:
      D.30413 = t->type;
      D.30437 = (unsigned int) D.30413;
      D.30438 = D.30437 * 16;
      slot_info = scalar_stack_slots + D.30438;
      goto <D.27841>;
      <D.27857>:
      D.30413 = t->type;
      D.30437 = (unsigned int) D.30413;
      D.30438 = D.30437 * 16;
      slot_info = scalar_stack_slots + D.30438;
      goto <D.27841>;
      <D.27841>:
      <D.30432>:
      slot = 16777215;
      D.30465 = cfg->comp_done;
      D.30466 = D.30465 & 16;
      if (D.30466 != 0) goto <D.30467>; else goto <D.30468>;
      <D.30467>:
      goto <D.27861>;
      <D.27860>:
      {
        struct MonoMethodVar * amv;

        D.30469 = slot_info->active;
        amv = D.30469->data;
        D.30470 = amv->range.last_use.abs_pos;
        D.30471 = vmv->range.first_use.abs_pos;
        if (D.30470 > D.30471) goto <D.27859>; else goto <D.30472>;
        <D.30472>:
        D.30469 = slot_info->active;
        D.30469 = slot_info->active;
        D.30473 = monoeg_g_list_delete_link (D.30469, D.30469);
        slot_info->active = D.30473;
        D.30379 = cfg->mempool;
        D.30474 = slot_info->slots;
        D.30475 = amv->idx;
        D.30476 = D.30475 * 4;
        D.30477 = offsets + D.30476;
        D.30478 = *D.30477;
        D.30479 = (void *) D.30478;
        D.30480 = g_slist_prepend_mempool (D.30379, D.30474, D.30479);
        slot_info->slots = D.30480;
      }
      <D.27861>:
      D.30469 = slot_info->active;
      if (D.30469 != 0B) goto <D.27860>; else goto <D.27859>;
      <D.27859>:
      D.30391 = inst->flags;
      D.30392 = (int) D.30391;
      D.30481 = D.30392 & 20;
      if (D.30481 == 0) goto <D.30482>; else goto <D.30483>;
      <D.30482>:
      D.30474 = slot_info->slots;
      if (D.30474 != 0B) goto <D.30484>; else goto <D.30485>;
      <D.30484>:
      D.30474 = slot_info->slots;
      D.30486 = D.30474->data;
      slot = (int) D.30486;
      D.30474 = slot_info->slots;
      D.30487 = D.30474->next;
      slot_info->slots = D.30487;
      <D.30485>:
      D.30469 = slot_info->active;
      D.30488 = mono_varlist_insert_sorted (cfg, D.30469, vmv, 1);
      slot_info->active = D.30488;
      <D.30483>:
      <D.30468>:
      {
        static int count = 0;

        count.59 = count;
        count.60 = count.59 + 1;
        count = count.60;
      }
      D.30391 = inst->flags;
      D.30392 = (int) D.30391;
      D.30491 = D.30392 & 32;
      if (D.30491 != 0) goto <D.30492>; else goto <D.30493>;
      <D.30492>:
      size = 208;
      align = 4;
      reuse_slot = 0;
      <D.30493>:
      if (reuse_slot == 0) goto <D.30494>; else goto <D.30495>;
      <D.30494>:
      slot = 16777215;
      <D.30495>:
      if (slot == 16777215) goto <D.30496>; else goto <D.30497>;
      <D.30496>:
      D.30498 = mono_type_is_struct (t);
      if (D.30498 != 0) goto <D.30499>; else goto <D.30500>;
      <D.30499>:
      align.61 = align;
      align.62 = MAX_EXPR <align.61, 4>;
      align = align.62;
      D.30504 = mono_class_from_mono_type (t);
      D.30505 = mono_class_min_align (D.30504);
      D.30506 = (unsigned int) D.30505;
      align.61 = align;
      if (D.30506 >= align.61) goto <D.30507>; else goto <D.30508>;
      <D.30507>:
      D.30509 = mono_class_from_mono_type (t);
      D.30510 = mono_class_min_align (D.30509);
      iftmp.63 = (guint32) D.30510;
      goto <D.30511>;
      <D.30508>:
      iftmp.63 = align;
      <D.30511>:
      align = iftmp.63;
      align.61 = align;
      size.64 = (unsigned int) size;
      D.30513 = align.61 + size.64;
      D.30514 = D.30513 + 4294967295;
      align.61 = align;
      D.30515 = -align.61;
      D.30516 = D.30514 & D.30515;
      size = (int) D.30516;
      <D.30500>:
      if (backward != 0) goto <D.30517>; else goto <D.30518>;
      <D.30517>:
      offset = offset + size;
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.30520 = align.61 + offset.65;
      D.30521 = D.30520 + 4294967295;
      offset = (int) D.30521;
      align.61 = align;
      D.30515 = -align.61;
      offset.65 = (unsigned int) offset;
      D.30522 = D.30515 & offset.65;
      offset = (int) D.30522;
      slot = offset;
      goto <D.30523>;
      <D.30518>:
      align.61 = align;
      offset.65 = (unsigned int) offset;
      D.30520 = align.61 + offset.65;
      D.30521 = D.30520 + 4294967295;
      offset = (int) D.30521;
      align.61 = align;
      D.30515 = -align.61;
      offset.65 = (unsigned int) offset;
      D.30522 = D.30515 & offset.65;
      offset = (int) D.30522;
      slot = offset;
      offset = offset + size;
      <D.30523>:
      D.30524 = *stack_align;
      align.61 = align;
      D.30525 = MAX_EXPR <D.30524, align.61>;
      *stack_align = D.30525;
      <D.30497>:
      D.30397 = vmv->idx;
      D.30398 = D.30397 * 4;
      D.30526 = offsets + D.30398;
      *D.30526 = slot;
      <D.27838>:
      l = l->next;
      <D.27864>:
      if (l != 0B) goto <D.27863>; else goto <D.27865>;
      <D.27865>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.27867>;
      <D.27866>:
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      D.30527 = scalar_stack_slots + D.30442;
      D.30528 = D.30527->active;
      if (D.30528 != 0B) goto <D.30529>; else goto <D.30530>;
      <D.30529>:
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      D.30527 = scalar_stack_slots + D.30442;
      D.30528 = D.30527->active;
      monoeg_g_list_free (D.30528);
      <D.30530>:
      i = i + 1;
      <D.27867>:
      if (i <= 68) goto <D.27866>; else goto <D.27868>;
      <D.27868>:
      i = 0;
      goto <D.27870>;
      <D.27869>:
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      D.30443 = vtype_stack_slots + D.30442;
      D.30531 = D.30443->active;
      if (D.30531 != 0B) goto <D.30532>; else goto <D.30533>;
      <D.30532>:
      i.54 = (unsigned int) i;
      D.30442 = i.54 * 16;
      D.30443 = vtype_stack_slots + D.30442;
      D.30531 = D.30443->active;
      monoeg_g_list_free (D.30531);
      <D.30533>:
      i = i + 1;
      <D.27870>:
      if (i < nvtypes) goto <D.27869>; else goto <D.27871>;
      <D.27871>:
      D.30534 = cfg->stat_locals_stack_size;
      D.30535 = D.30534 + offset;
      cfg->stat_locals_stack_size = D.30535;
      offset.65 = (unsigned int) offset;
      *stack_size = offset.65;
      D.30378 = offsets;
      return D.30378;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_allocate_stack_slots2 (struct MonoCompile * cfg, gboolean backward, guint32 * stack_size, guint32 * stack_align)
{
  struct MonoMemPool * D.30538;
  unsigned int D.30539;
  unsigned int D.30540;
  unsigned int i.66;
  unsigned int D.30542;
  gint32 * D.30543;
  unsigned int i.67;
  unsigned int D.30545;
  struct MonoInst * * D.30546;
  struct MonoInst * * D.30547;
  struct MonoMethodVar * D.30548;
  unsigned int D.30549;
  unsigned char D.30552;
  int D.30553;
  int D.30554;
  short unsigned int D.30556;
  struct GList * D.30558;
  unsigned int D.30559;
  unsigned int D.30560;
  struct MonoInst * * D.30561;
  struct MonoType * D.30562;
  int D.30563;
  int D.30566;
  int D.30571;
  int D.30573;
  unsigned char D.30575;
  struct MonoClass * D.30577;
  int ialign.68;
  unsigned int ialign.69;
  unsigned char D.30582;
  unsigned char D.30583;
  int D.30586;
  int D.30587;
  unsigned int D.30590;
  unsigned int D.30591;
  struct MonoClass * D.30594;
  unsigned int D.30595;
  struct StackSlotInfo * D.30596;
  struct MonoClass * D.30597;
  _Bool D.30602;
  long int D.30603;
  long int D.30604;
  unsigned int nvtypes.70;
  unsigned int D.30608;
  struct StackSlotInfo * D.30609;
  unsigned char D.30610;
  unsigned char D.30613;
  unsigned int D.30618;
  unsigned int D.30619;
  struct MonoLiveInterval * D.30622;
  struct MonoLiveRange2 * D.30623;
  int D.30626;
  unsigned char D.30630;
  struct MonoLiveInterval * D.30634;
  struct MonoLiveRange2 * D.30635;
  int D.30636;
  struct GList * D.30639;
  struct GList * D.30640;
  struct GSList * D.30641;
  unsigned int D.30642;
  unsigned int D.30643;
  gint32 * D.30644;
  int D.30645;
  void * D.30646;
  struct GSList * D.30647;
  int D.30648;
  struct GList * D.30651;
  struct GList * D.30652;
  struct GList * D.30653;
  struct MonoLiveInterval * D.30654;
  struct MonoLiveRange2 * D.30655;
  int D.30656;
  struct GList * D.30659;
  int D.30660;
  struct GList * D.30663;
  struct GList * D.30664;
  void * D.30669;
  struct GSList * D.30670;
  struct GList * D.30671;
  int D.30672;
  int D.30679;
  unsigned int align.71;
  unsigned int align.72;
  guint32 iftmp.73;
  struct MonoClass * D.30685;
  int D.30686;
  unsigned int D.30687;
  struct MonoClass * D.30690;
  int D.30691;
  unsigned int offset.74;
  unsigned int D.30696;
  unsigned int D.30697;
  unsigned int D.30698;
  unsigned int D.30699;
  unsigned int D.30701;
  gint32 * D.30704;
  struct StackSlotInfo * D.30705;
  struct GList * D.30706;
  struct GList * D.30709;
  int D.30712;
  int D.30713;
  gint32 * D.30714;
  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.30538 = cfg->mempool;
      scalar_stack_slots = mono_mempool_alloc0 (D.30538, 1104);
      vtype_stack_slots = 0B;
      nvtypes = 0;
      D.30538 = cfg->mempool;
      D.30539 = cfg->num_varinfo;
      D.30540 = D.30539 * 4;
      offsets = mono_mempool_alloc (D.30538, D.30540);
      i = 0;
      goto <D.27759>;
      <D.27758>:
      i.66 = (unsigned int) i;
      D.30542 = i.66 * 4;
      D.30543 = offsets + D.30542;
      *D.30543 = -1;
      i = i + 1;
      <D.27759>:
      i.67 = (unsigned int) i;
      D.30539 = cfg->num_varinfo;
      if (i.67 < D.30539) goto <D.27758>; else goto <D.27760>;
      <D.27760>:
      D.30545 = cfg->locals_start;
      i = (int) D.30545;
      goto <D.27763>;
      <D.27762>:
      D.30546 = cfg->varinfo;
      i.66 = (unsigned int) i;
      D.30542 = i.66 * 4;
      D.30547 = D.30546 + D.30542;
      inst = *D.30547;
      D.30548 = cfg->vars;
      i.66 = (unsigned int) i;
      D.30549 = i.66 * 56;
      vmv = D.30548 + D.30549;
      D.30552 = inst->flags;
      D.30553 = (int) D.30552;
      D.30554 = D.30553 & 2;
      if (D.30554 != 0) goto <D.30550>; else goto <D.30555>;
      <D.30555>:
      D.30556 = inst->opcode;
      if (D.30556 == 366) goto <D.30550>; else goto <D.30557>;
      <D.30557>:
      D.30556 = inst->opcode;
      if (D.30556 == 367) goto <D.30550>; else goto <D.30551>;
      <D.30550>:
      // predicted unlikely by continue predictor.
      goto <D.27761>;
      <D.30551>:
      vars = monoeg_g_list_prepend (vars, vmv);
      <D.27761>:
      i = i + 1;
      <D.27763>:
      i.67 = (unsigned int) i;
      D.30539 = cfg->num_varinfo;
      if (i.67 < D.30539) goto <D.27762>; else goto <D.27764>;
      <D.27764>:
      D.30558 = monoeg_g_list_copy (vars);
      vars = monoeg_g_list_sort (D.30558, compare_by_interval_start_pos_func);
      offset = 0;
      *stack_align = 0;
      unhandled = vars;
      goto <D.27801>;
      <D.27800>:
      {
        struct MonoMethodVar * current;

        current = unhandled->data;
        vmv = current;
        D.30546 = cfg->varinfo;
        D.30559 = vmv->idx;
        D.30560 = D.30559 * 4;
        D.30561 = D.30546 + D.30560;
        inst = *D.30561;
        D.30562 = inst->data.op[1].vtype;
        t = mono_type_get_underlying_type (D.30562);
        D.30563 = cfg->gsharedvt;
        if (D.30563 != 0) goto <D.30564>; else goto <D.30565>;
        <D.30564>:
        D.30566 = mini_is_gsharedvt_variable_type (cfg, t);
        if (D.30566 != 0) goto <D.30567>; else goto <D.30568>;
        <D.30567>:
        // predicted unlikely by continue predictor.
        goto <D.27766>;
        <D.30568>:
        <D.30565>:
        D.30571 = inst->backend.is_pinvoke;
        if (D.30571 != 0) goto <D.30572>; else goto <D.30569>;
        <D.30572>:
        D.30573 = mono_type_is_struct (t);
        if (D.30573 != 0) goto <D.30574>; else goto <D.30569>;
        <D.30574>:
        D.30575 = t->type;
        if (D.30575 != 22) goto <D.30576>; else goto <D.30569>;
        <D.30576>:
        D.30577 = mono_class_from_mono_type (t);
        size = mono_class_native_size (D.30577, &align);
        goto <D.30570>;
        <D.30569>:
        {
          int ialign;

          try
            {
              size = mono_type_size (t, &ialign);
              ialign.68 = ialign;
              ialign.69 = (unsigned int) ialign.68;
              align = ialign.69;
              if (0 != 0) goto <D.30580>; else goto <D.30581>;
              <D.30580>:
              align = 16;
              <D.30581>:
            }
          finally
            {
              ialign = {CLOBBER};
            }
        }
        <D.30570>:
        reuse_slot = 1;
        D.30582 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.30583 = D.30582 & 1;
        if (D.30583 != 0) goto <D.30584>; else goto <D.30585>;
        <D.30584>:
        reuse_slot = 0;
        <D.30585>:
        D.30575 = t->type;
        D.30586 = (int) D.30575;
        switch (D.30586) <default: <D.27783>, case 8: <D.27777>, case 14: <D.27782>, case 15: <D.27774>, case 17: <D.27770>, case 18: <D.27778>, case 20: <D.27780>, case 21: <D.27768>, case 24: <D.27775>, case 25: <D.27776>, case 28: <D.27779>, case 29: <D.27781>>
        <D.27768>:
        D.30587 = mono_type_generic_inst_is_valuetype (t);
        if (D.30587 == 0) goto <D.30588>; else goto <D.30589>;
        <D.30588>:
        D.30575 = t->type;
        D.30590 = (unsigned int) D.30575;
        D.30591 = D.30590 * 16;
        slot_info = scalar_stack_slots + D.30591;
        goto <D.27769>;
        <D.30589>:
        <D.27770>:
        if (vtype_stack_slots == 0B) goto <D.30592>; else goto <D.30593>;
        <D.30592>:
        D.30538 = cfg->mempool;
        vtype_stack_slots = mono_mempool_alloc0 (D.30538, 4096);
        <D.30593>:
        i = 0;
        goto <D.27773>;
        <D.27772>:
        D.30594 = t->data.klass;
        i.66 = (unsigned int) i;
        D.30595 = i.66 * 16;
        D.30596 = vtype_stack_slots + D.30595;
        D.30597 = D.30596->vtype;
        if (D.30594 == D.30597) goto <D.27771>; else goto <D.30598>;
        <D.30598>:
        i = i + 1;
        <D.27773>:
        if (i < nvtypes) goto <D.27772>; else goto <D.27771>;
        <D.27771>:
        if (i < nvtypes) goto <D.30599>; else goto <D.30600>;
        <D.30599>:
        i.66 = (unsigned int) i;
        D.30595 = i.66 * 16;
        slot_info = vtype_stack_slots + D.30595;
        goto <D.30601>;
        <D.30600>:
        D.30602 = nvtypes > 255;
        D.30603 = (long int) D.30602;
        D.30604 = __builtin_expect (D.30603, 0);
        if (D.30604 != 0) goto <D.30605>; else goto <D.30606>;
        <D.30605>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 1875, "nvtypes < 256");
        <D.30606>:
        nvtypes.70 = (unsigned int) nvtypes;
        D.30608 = nvtypes.70 * 16;
        D.30609 = vtype_stack_slots + D.30608;
        D.30594 = t->data.klass;
        D.30609->vtype = D.30594;
        nvtypes.70 = (unsigned int) nvtypes;
        D.30608 = nvtypes.70 * 16;
        slot_info = vtype_stack_slots + D.30608;
        nvtypes = nvtypes + 1;
        <D.30601>:
        D.30582 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.30610 = D.30582 & 2;
        if (D.30610 != 0) goto <D.30611>; else goto <D.30612>;
        <D.30611>:
        reuse_slot = 0;
        <D.30612>:
        goto <D.27769>;
        <D.27774>:
        <D.27775>:
        <D.27776>:
        <D.27777>:
        D.30582 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.30613 = D.30582 & 4;
        if (D.30613 != 0) goto <D.30614>; else goto <D.30615>;
        <D.30614>:
        slot_info = scalar_stack_slots + 384;
        goto <D.27769>;
        <D.30615>:
        <D.27778>:
        <D.27779>:
        <D.27780>:
        <D.27781>:
        <D.27782>:
        slot_info = scalar_stack_slots + 288;
        D.30582 = BIT_FIELD_REF <*cfg, 8, 3408>;
        D.30610 = D.30582 & 2;
        if (D.30610 != 0) goto <D.30616>; else goto <D.30617>;
        <D.30616>:
        reuse_slot = 0;
        <D.30617>:
        goto <D.27769>;
        <D.27783>:
        D.30575 = t->type;
        D.30590 = (unsigned int) D.30575;
        D.30591 = D.30590 * 16;
        slot_info = scalar_stack_slots + D.30591;
        <D.27769>:
        slot = 16777215;
        D.30618 = cfg->comp_done;
        D.30619 = D.30618 & 16;
        if (D.30619 != 0) goto <D.30620>; else goto <D.30621>;
        <D.30620>:
        {
          int pos;
          gboolean changed;

          D.30622 = current->interval;
          D.30623 = D.30622->range;
          if (D.30623 == 0B) goto <D.30624>; else goto <D.30625>;
          <D.30624>:
          D.30552 = inst->flags;
          D.30553 = (int) D.30552;
          D.30626 = D.30553 & 20;
          if (D.30626 != 0) goto <D.30627>; else goto <D.30628>;
          <D.30627>:
          pos = -1;
          goto <D.30629>;
          <D.30628>:
          D.30552 = inst->flags;
          D.30630 = D.30552 | 2;
          inst->flags = D.30630;
          // predicted unlikely by continue predictor.
          goto <D.27766>;
          <D.30629>:
          goto <D.30631>;
          <D.30625>:
          D.30622 = current->interval;
          D.30623 = D.30622->range;
          pos = D.30623->from;
          <D.30631>:
          D.30622 = current->interval;
          D.30623 = D.30622->range;
          if (D.30623 != 0B) goto <D.30632>; else goto <D.30633>;
          <D.30632>:
          <D.30633>:
          changed = 1;
          goto <D.27791>;
          <D.27790>:
          changed = 0;
          l = slot_info->active;
          goto <D.27789>;
          <D.27788>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.30634 = v->interval;
            D.30635 = D.30634->last_range;
            D.30636 = D.30635->to;
            if (D.30636 < pos) goto <D.30637>; else goto <D.30638>;
            <D.30637>:
            D.30639 = slot_info->active;
            D.30640 = monoeg_g_list_delete_link (D.30639, l);
            slot_info->active = D.30640;
            D.30538 = cfg->mempool;
            D.30641 = slot_info->slots;
            D.30642 = v->idx;
            D.30643 = D.30642 * 4;
            D.30644 = offsets + D.30643;
            D.30645 = *D.30644;
            D.30646 = (void *) D.30645;
            D.30647 = g_slist_prepend_mempool (D.30538, D.30641, D.30646);
            slot_info->slots = D.30647;
            changed = 1;
            goto <D.27787>;
            <D.30638>:
            D.30634 = v->interval;
            D.30648 = mono_linterval_covers (D.30634, pos);
            if (D.30648 == 0) goto <D.30649>; else goto <D.30650>;
            <D.30649>:
            D.30651 = slot_info->inactive;
            D.30652 = monoeg_g_list_append (D.30651, v);
            slot_info->inactive = D.30652;
            D.30639 = slot_info->active;
            D.30653 = monoeg_g_list_delete_link (D.30639, l);
            slot_info->active = D.30653;
            changed = 1;
            goto <D.27787>;
            <D.30650>:
          }
          l = l->next;
          <D.27789>:
          if (l != 0B) goto <D.27788>; else goto <D.27787>;
          <D.27787>:
          <D.27791>:
          if (changed != 0) goto <D.27790>; else goto <D.27792>;
          <D.27792>:
          changed = 1;
          goto <D.27798>;
          <D.27797>:
          changed = 0;
          l = slot_info->inactive;
          goto <D.27796>;
          <D.27795>:
          {
            struct MonoMethodVar * v;

            v = l->data;
            D.30654 = v->interval;
            D.30655 = D.30654->last_range;
            D.30656 = D.30655->to;
            if (D.30656 < pos) goto <D.30657>; else goto <D.30658>;
            <D.30657>:
            D.30651 = slot_info->inactive;
            D.30659 = monoeg_g_list_delete_link (D.30651, l);
            slot_info->inactive = D.30659;
            changed = 1;
            goto <D.27794>;
            <D.30658>:
            D.30654 = v->interval;
            D.30660 = mono_linterval_covers (D.30654, pos);
            if (D.30660 != 0) goto <D.30661>; else goto <D.30662>;
            <D.30661>:
            D.30639 = slot_info->active;
            D.30663 = monoeg_g_list_append (D.30639, v);
            slot_info->active = D.30663;
            D.30651 = slot_info->inactive;
            D.30664 = monoeg_g_list_delete_link (D.30651, l);
            slot_info->inactive = D.30664;
            changed = 1;
            goto <D.27794>;
            <D.30662>:
          }
          l = l->next;
          <D.27796>:
          if (l != 0B) goto <D.27795>; else goto <D.27794>;
          <D.27794>:
          <D.27798>:
          if (changed != 0) goto <D.27797>; else goto <D.27799>;
          <D.27799>:
          D.30552 = inst->flags;
          D.30553 = (int) D.30552;
          D.30626 = D.30553 & 20;
          if (D.30626 == 0) goto <D.30665>; else goto <D.30666>;
          <D.30665>:
          D.30641 = slot_info->slots;
          if (D.30641 != 0B) goto <D.30667>; else goto <D.30668>;
          <D.30667>:
          D.30641 = slot_info->slots;
          D.30669 = D.30641->data;
          slot = (int) D.30669;
          D.30641 = slot_info->slots;
          D.30670 = D.30641->next;
          slot_info->slots = D.30670;
          <D.30668>:
          D.30639 = slot_info->active;
          D.30671 = mono_varlist_insert_sorted (cfg, D.30639, vmv, 1);
          slot_info->active = D.30671;
          <D.30666>:
        }
        <D.30621>:
        D.30552 = inst->flags;
        D.30553 = (int) D.30552;
        D.30672 = D.30553 & 32;
        if (D.30672 != 0) goto <D.30673>; else goto <D.30674>;
        <D.30673>:
        size = 208;
        align = 4;
        reuse_slot = 0;
        <D.30674>:
        if (reuse_slot == 0) goto <D.30675>; else goto <D.30676>;
        <D.30675>:
        slot = 16777215;
        <D.30676>:
        if (slot == 16777215) goto <D.30677>; else goto <D.30678>;
        <D.30677>:
        D.30679 = mono_type_is_struct (t);
        if (D.30679 != 0) goto <D.30680>; else goto <D.30681>;
        <D.30680>:
        align.71 = align;
        align.72 = MAX_EXPR <align.71, 4>;
        align = align.72;
        D.30685 = mono_class_from_mono_type (t);
        D.30686 = mono_class_min_align (D.30685);
        D.30687 = (unsigned int) D.30686;
        align.71 = align;
        if (D.30687 >= align.71) goto <D.30688>; else goto <D.30689>;
        <D.30688>:
        D.30690 = mono_class_from_mono_type (t);
        D.30691 = mono_class_min_align (D.30690);
        iftmp.73 = (guint32) D.30691;
        goto <D.30692>;
        <D.30689>:
        iftmp.73 = align;
        <D.30692>:
        align = iftmp.73;
        <D.30681>:
        if (backward != 0) goto <D.30693>; else goto <D.30694>;
        <D.30693>:
        offset = offset + size;
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.30696 = align.71 + offset.74;
        D.30697 = D.30696 + 4294967295;
        offset = (int) D.30697;
        align.71 = align;
        D.30698 = -align.71;
        offset.74 = (unsigned int) offset;
        D.30699 = D.30698 & offset.74;
        offset = (int) D.30699;
        slot = offset;
        goto <D.30700>;
        <D.30694>:
        align.71 = align;
        offset.74 = (unsigned int) offset;
        D.30696 = align.71 + offset.74;
        D.30697 = D.30696 + 4294967295;
        offset = (int) D.30697;
        align.71 = align;
        D.30698 = -align.71;
        offset.74 = (unsigned int) offset;
        D.30699 = D.30698 & offset.74;
        offset = (int) D.30699;
        slot = offset;
        offset = offset + size;
        <D.30700>:
        D.30701 = *stack_align;
        if (D.30701 == 0) goto <D.30702>; else goto <D.30703>;
        <D.30702>:
        align.71 = align;
        *stack_align = align.71;
        <D.30703>:
        <D.30678>:
        D.30559 = vmv->idx;
        D.30560 = D.30559 * 4;
        D.30704 = offsets + D.30560;
        *D.30704 = slot;
      }
      <D.27766>:
      unhandled = unhandled->next;
      <D.27801>:
      if (unhandled != 0B) goto <D.27800>; else goto <D.27802>;
      <D.27802>:
      monoeg_g_list_free (vars);
      i = 0;
      goto <D.27804>;
      <D.27803>:
      i.66 = (unsigned int) i;
      D.30595 = i.66 * 16;
      D.30705 = scalar_stack_slots + D.30595;
      D.30706 = D.30705->active;
      if (D.30706 != 0B) goto <D.30707>; else goto <D.30708>;
      <D.30707>:
      i.66 = (unsigned int) i;
      D.30595 = i.66 * 16;
      D.30705 = scalar_stack_slots + D.30595;
      D.30706 = D.30705->active;
      monoeg_g_list_free (D.30706);
      <D.30708>:
      i = i + 1;
      <D.27804>:
      if (i <= 68) goto <D.27803>; else goto <D.27805>;
      <D.27805>:
      i = 0;
      goto <D.27807>;
      <D.27806>:
      i.66 = (unsigned int) i;
      D.30595 = i.66 * 16;
      D.30596 = vtype_stack_slots + D.30595;
      D.30709 = D.30596->active;
      if (D.30709 != 0B) goto <D.30710>; else goto <D.30711>;
      <D.30710>:
      i.66 = (unsigned int) i;
      D.30595 = i.66 * 16;
      D.30596 = vtype_stack_slots + D.30595;
      D.30709 = D.30596->active;
      monoeg_g_list_free (D.30709);
      <D.30711>:
      i = i + 1;
      <D.27807>:
      if (i < nvtypes) goto <D.27806>; else goto <D.27808>;
      <D.27808>:
      D.30712 = cfg->stat_locals_stack_size;
      D.30713 = D.30712 + offset;
      cfg->stat_locals_stack_size = D.30713;
      offset.74 = (unsigned int) offset;
      *stack_size = offset.74;
      D.30714 = offsets;
      return D.30714;
    }
  finally
    {
      align = {CLOBBER};
    }
}


compare_by_interval_start_pos_func (const void * a, const void * b)
{
  gint D.30719;
  struct MonoLiveInterval * D.30721;
  struct MonoLiveRange2 * D.30722;
  struct MonoLiveInterval * D.30724;
  struct MonoLiveRange2 * D.30725;
  int D.30727;
  int D.30728;
  struct MonoMethodVar * v1;
  struct MonoMethodVar * v2;

  v1 = a;
  v2 = b;
  if (v1 == v2) goto <D.30717>; else goto <D.30718>;
  <D.30717>:
  D.30719 = 0;
  return D.30719;
  <D.30718>:
  D.30721 = v1->interval;
  D.30722 = D.30721->range;
  if (D.30722 != 0B) goto <D.30723>; else goto <D.30720>;
  <D.30723>:
  D.30724 = v2->interval;
  D.30725 = D.30724->range;
  if (D.30725 != 0B) goto <D.30726>; else goto <D.30720>;
  <D.30726>:
  D.30721 = v1->interval;
  D.30722 = D.30721->range;
  D.30727 = D.30722->from;
  D.30724 = v2->interval;
  D.30725 = D.30724->range;
  D.30728 = D.30725->from;
  D.30719 = D.30727 - D.30728;
  return D.30719;
  <D.30720>:
  D.30721 = v1->interval;
  D.30722 = D.30721->range;
  if (D.30722 != 0B) goto <D.30729>; else goto <D.30730>;
  <D.30729>:
  D.30719 = -1;
  return D.30719;
  <D.30730>:
  D.30719 = 1;
  return D.30719;
}


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

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


mono_find_jit_opcode_emulation (int opcode)
{
  unsigned int opcode.75;
  _Bool D.30735;
  long int D.30736;
  long int D.30737;
  int D.30740;
  unsigned char D.30741;
  int D.30742;
  int D.30743;
  int D.30744;
  int D.30745;
  short int * emul_opcode_opcodes.76;
  unsigned int i.77;
  unsigned int D.30750;
  short int * D.30751;
  short int D.30752;
  int D.30753;
  struct MonoJitICallInfo * D.30756;
  struct MonoJitICallInfo * * emul_opcode_map.78;
  unsigned int D.30758;
  struct MonoJitICallInfo * * D.30759;
  short int emul_opcode_num.79;
  int D.30761;

  opcode.75 = (unsigned int) opcode;
  D.30735 = opcode.75 > 846;
  D.30736 = (long int) D.30735;
  D.30737 = __builtin_expect (D.30736, 0);
  if (D.30737 != 0) goto <D.30738>; else goto <D.30739>;
  <D.30738>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2356, "opcode >= 0 && opcode <= OP_LAST");
  <D.30739>:
  D.30740 = opcode >> 6;
  D.30741 = emul_opcode_hit_cache[D.30740];
  D.30742 = (int) D.30741;
  D.30743 = opcode & 7;
  D.30744 = D.30742 >> D.30743;
  D.30745 = D.30744 & 1;
  if (D.30745 != 0) goto <D.30746>; else goto <D.30747>;
  <D.30746>:
  {
    int i;

    i = 0;
    goto <D.27882>;
    <D.27881>:
    emul_opcode_opcodes.76 = emul_opcode_opcodes;
    i.77 = (unsigned int) i;
    D.30750 = i.77 * 2;
    D.30751 = emul_opcode_opcodes.76 + D.30750;
    D.30752 = *D.30751;
    D.30753 = (int) D.30752;
    if (D.30753 == opcode) goto <D.30754>; else goto <D.30755>;
    <D.30754>:
    emul_opcode_map.78 = emul_opcode_map;
    i.77 = (unsigned int) i;
    D.30758 = i.77 * 4;
    D.30759 = emul_opcode_map.78 + D.30758;
    D.30756 = *D.30759;
    return D.30756;
    <D.30755>:
    i = i + 1;
    <D.27882>:
    emul_opcode_num.79 = emul_opcode_num;
    D.30761 = (int) emul_opcode_num.79;
    if (D.30761 > i) goto <D.27881>; else goto <D.27883>;
    <D.27883>:
  }
  <D.30747>:
  D.30756 = 0B;
  return D.30756;
}


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

  D.30763 = bb->last_ins;
  if (D.30763 != 0B) goto <D.30764>; else goto <D.30765>;
  <D.30764>:
  D.30763 = bb->last_ins;
  D.30763->next = inst;
  D.30763 = bb->last_ins;
  inst->prev = D.30763;
  bb->last_ins = inst;
  goto <D.30766>;
  <D.30765>:
  bb->last_ins = inst;
  D.30763 = bb->last_ins;
  bb->code = D.30763;
  <D.30766>:
}


mono_bblock_insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.30771;
  struct MonoInst * D.30775;

  if (ins == 0B) goto <D.30767>; else goto <D.30768>;
  <D.30767>:
  ins = bb->code;
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  if (ins != 0B) goto <D.30769>; else goto <D.30770>;
  <D.30769>:
  ins->prev = ins_to_insert;
  <D.30770>:
  D.30771 = bb->last_ins;
  if (D.30771 == 0B) goto <D.30772>; else goto <D.30773>;
  <D.30772>:
  bb->last_ins = ins_to_insert;
  <D.30773>:
  goto <D.30774>;
  <D.30768>:
  D.30775 = ins->next;
  ins_to_insert->next = D.30775;
  D.30775 = ins->next;
  if (D.30775 != 0B) goto <D.30776>; else goto <D.30777>;
  <D.30776>:
  D.30775 = ins->next;
  D.30775->prev = ins_to_insert;
  <D.30777>:
  ins->next = ins_to_insert;
  ins_to_insert->prev = ins;
  D.30771 = bb->last_ins;
  if (D.30771 == ins) goto <D.30778>; else goto <D.30779>;
  <D.30778>:
  bb->last_ins = ins_to_insert;
  <D.30779>:
  <D.30774>:
}


mono_bblock_insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * ins_to_insert)
{
  struct MonoInst * D.30784;
  struct MonoInst * D.30788;
  struct MonoInst * D.30791;

  if (ins == 0B) goto <D.30780>; else goto <D.30781>;
  <D.30780>:
  ins = bb->code;
  if (ins != 0B) goto <D.30782>; else goto <D.30783>;
  <D.30782>:
  ins->prev = ins_to_insert;
  <D.30783>:
  bb->code = ins_to_insert;
  ins_to_insert->next = ins;
  D.30784 = bb->last_ins;
  if (D.30784 == 0B) goto <D.30785>; else goto <D.30786>;
  <D.30785>:
  bb->last_ins = ins_to_insert;
  <D.30786>:
  goto <D.30787>;
  <D.30781>:
  D.30788 = ins->prev;
  if (D.30788 != 0B) goto <D.30789>; else goto <D.30790>;
  <D.30789>:
  D.30788 = ins->prev;
  D.30788->next = ins_to_insert;
  <D.30790>:
  D.30788 = ins->prev;
  ins_to_insert->prev = D.30788;
  ins->prev = ins_to_insert;
  ins_to_insert->next = ins;
  D.30791 = bb->code;
  if (D.30791 == ins) goto <D.30792>; else goto <D.30793>;
  <D.30792>:
  bb->code = ins_to_insert;
  <D.30793>:
  <D.30787>:
}


mono_verify_bblock (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.30794;
  _Bool D.30795;
  long int D.30796;
  long int D.30797;
  struct MonoInst * D.30800;
  struct MonoInst * D.30803;
  _Bool D.30804;
  long int D.30805;
  long int D.30806;
  struct MonoInst * ins;
  struct MonoInst * prev;

  prev = 0B;
  ins = bb->code;
  goto <D.27950>;
  <D.27949>:
  D.30794 = ins->prev;
  D.30795 = D.30794 != prev;
  D.30796 = (long int) D.30795;
  D.30797 = __builtin_expect (D.30796, 0);
  if (D.30797 != 0) goto <D.30798>; else goto <D.30799>;
  <D.30798>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2550, "ins->prev == prev");
  <D.30799>:
  prev = ins;
  ins = ins->next;
  <D.27950>:
  if (ins != 0B) goto <D.27949>; else goto <D.27951>;
  <D.27951>:
  D.30800 = bb->last_ins;
  if (D.30800 != 0B) goto <D.30801>; else goto <D.30802>;
  <D.30801>:
  D.30800 = bb->last_ins;
  D.30803 = D.30800->next;
  D.30804 = D.30803 != 0B;
  D.30805 = (long int) D.30804;
  D.30806 = __builtin_expect (D.30805, 0);
  if (D.30806 != 0) goto <D.30807>; else goto <D.30808>;
  <D.30807>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2554, "!bb->last_ins->next");
  <D.30808>:
  <D.30802>:
}


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

  bb = cfg->bb_entry;
  goto <D.27957>;
  <D.27956>:
  mono_verify_bblock (bb);
  bb = bb->next_bb;
  <D.27957>:
  if (bb != 0B) goto <D.27956>; else goto <D.27958>;
  <D.27958>:
}


mono_destroy_compile (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.30809;
  struct MonoRegState * D.30812;
  struct GHashTable * D.30815;
  struct GHashTable * D.30818;
  void * D.30821;
  struct GList * D.30822;
  struct GHashTable * D.30823;
  struct GHashTable * D.30824;
  struct MonoMemPool * D.30827;
  struct MonoInst * * D.30828;
  struct MonoMethodVar * D.30829;
  char * D.30830;
  struct GSList * l;

  D.30809 = cfg->header;
  if (D.30809 != 0B) goto <D.30810>; else goto <D.30811>;
  <D.30810>:
  D.30809 = cfg->header;
  mono_metadata_free_mh (D.30809);
  <D.30811>:
  mono_free_loop_info (cfg);
  D.30812 = cfg->rs;
  if (D.30812 != 0B) goto <D.30813>; else goto <D.30814>;
  <D.30813>:
  D.30812 = cfg->rs;
  mono_regstate_free (D.30812);
  <D.30814>:
  D.30815 = cfg->spvars;
  if (D.30815 != 0B) goto <D.30816>; else goto <D.30817>;
  <D.30816>:
  D.30815 = cfg->spvars;
  monoeg_g_hash_table_destroy (D.30815);
  <D.30817>:
  D.30818 = cfg->exvars;
  if (D.30818 != 0B) goto <D.30819>; else goto <D.30820>;
  <D.30819>:
  D.30818 = cfg->exvars;
  monoeg_g_hash_table_destroy (D.30818);
  <D.30820>:
  l = cfg->headers_to_free;
  goto <D.27964>;
  <D.27963>:
  D.30821 = l->data;
  mono_metadata_free_mh (D.30821);
  l = l->next;
  <D.27964>:
  if (l != 0B) goto <D.27963>; else goto <D.27965>;
  <D.27965>:
  D.30822 = cfg->ldstr_list;
  monoeg_g_list_free (D.30822);
  D.30823 = cfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.30823);
  D.30824 = cfg->abs_patches;
  if (D.30824 != 0B) goto <D.30825>; else goto <D.30826>;
  <D.30825>:
  D.30824 = cfg->abs_patches;
  monoeg_g_hash_table_destroy (D.30824);
  <D.30826>:
  D.30827 = cfg->mempool;
  mono_mempool_destroy (D.30827);
  mono_debug_free_method (cfg);
  D.30828 = cfg->varinfo;
  monoeg_g_free (D.30828);
  D.30829 = cfg->vars;
  monoeg_g_free (D.30829);
  D.30830 = cfg->exception_message;
  monoeg_g_free (D.30830);
  monoeg_g_free (cfg);
}


mono_get_jit_tls_key ()
{
  pthread_key_t D.30831;

  D.30831 = mono_jit_tls_id;
  return D.30831;
}


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

  __asm__("	ldr	%0, 1f; b 2f; 1: .word mono_jit_tls(tpoff); 2:" : "=r" offset);
  D.30833 = offset;
  return D.30833;
}


mono_get_lmf_tls_offset ()
{
  gint32 D.30835;

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


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

  __asm__("	ldr	%0, 1f; b 2f; 1: .word mono_lmf_addr(tpoff); 2:" : "=r" offset);
  D.30837 = offset;
  return D.30837;
}


mono_get_lmf ()
{
  unsigned int mono_jit_tls_id.80;
  struct MonoLMF * D.30842;
  struct MonoJitTlsData * jit_tls;

  mono_jit_tls_id.80 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.80);
  if (jit_tls != 0B) goto <D.30840>; else goto <D.30841>;
  <D.30840>:
  D.30842 = jit_tls->lmf;
  return D.30842;
  <D.30841>:
  D.30842 = 0B;
  return D.30842;
}


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

  D.30844 = mono_lmf_addr;
  return D.30844;
}


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

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


mono_jit_thread_attach (struct MonoDomain * domain)
{
  void * mono_lmf_addr.81;
  struct MonoInternalThread * D.30852;
  struct MonoDomain * D.30855;
  struct MonoDomain * iftmp.82;
  struct MonoDomain * orig;

  if (domain == 0B) goto <D.30847>; else goto <D.30848>;
  <D.30847>:
  domain = mono_get_root_domain ();
  <D.30848>:
  mono_lmf_addr.81 = mono_lmf_addr;
  if (mono_lmf_addr.81 == 0B) goto <D.30850>; else goto <D.30851>;
  <D.30850>:
  mono_thread_attach (domain);
  D.30852 = mono_thread_internal_current ();
  mono_thread_set_state (D.30852, 4);
  <D.30851>:
  orig = mono_domain_get ();
  if (orig != domain) goto <D.30853>; else goto <D.30854>;
  <D.30853>:
  mono_domain_set (domain, 1);
  <D.30854>:
  if (orig != domain) goto <D.30857>; else goto <D.30858>;
  <D.30857>:
  iftmp.82 = orig;
  goto <D.30859>;
  <D.30858>:
  iftmp.82 = 0B;
  <D.30859>:
  D.30855 = iftmp.82;
  return D.30855;
}


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


mini_get_tls_offset (MonoTlsKey key)
{
  _Bool D.30863;
  long int D.30864;
  long int D.30865;
  int D.30868;
  int offset;

  switch (key) <default: <D.28048>, case 0: <D.28042>, case 1: <D.28044>, case 2: <D.28045>, case 3: <D.28046>, case 8: <D.28047>>
  <D.28042>:
  offset = mono_thread_get_tls_offset ();
  goto <D.28043>;
  <D.28044>:
  offset = mono_get_jit_tls_offset ();
  goto <D.28043>;
  <D.28045>:
  offset = mono_domain_get_tls_offset ();
  goto <D.28043>;
  <D.28046>:
  offset = mono_get_lmf_tls_offset ();
  goto <D.28043>;
  <D.28047>:
  offset = mono_get_lmf_addr_tls_offset ();
  goto <D.28043>;
  <D.28048>:
  offset = mono_tls_key_get_offset (key);
  D.30863 = offset == -1;
  D.30864 = (long int) D.30863;
  D.30865 = __builtin_expect (D.30864, 0);
  if (D.30865 != 0) goto <D.30866>; else goto <D.30867>;
  <D.30866>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2929, "offset != -1");
  <D.30867>:
  goto <D.28043>;
  <D.28043>:
  D.30868 = offset;
  return D.30868;
}


mini_tls_get_supported (struct MonoCompile * cfg, MonoTlsKey key)
{
  gboolean D.30872;
  unsigned char D.30873;
  unsigned char D.30874;
  int D.30877;
  _Bool D.30878;

  if (0 != 0) goto <D.30870>; else goto <D.30871>;
  <D.30870>:
  D.30872 = 0;
  return D.30872;
  <D.30871>:
  D.30873 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30874 = D.30873 & 64;
  if (D.30874 != 0) goto <D.30875>; else goto <D.30876>;
  <D.30875>:
  D.30872 = 0;
  return D.30872;
  <D.30876>:
  D.30877 = mini_get_tls_offset (key);
  D.30878 = D.30877 != -1;
  D.30872 = (gboolean) D.30878;
  return D.30872;
}


mono_create_tls_get (struct MonoCompile * cfg, MonoTlsKey key)
{
  unsigned char D.30880;
  unsigned char D.30881;
  struct MonoMemPool * D.30888;
  int D.30889;
  struct MonoInst * D.30890;
  guint16 iftmp.83;
  int D.30895;
  int D.30896;
  const unsigned char * D.30897;
  void * key.84;
  unsigned int D.30899;
  int D.30900;
  void * _offset.85;
  unsigned int D.30903;
  int D.30904;
  struct MonoBasicBlock * D.30905;
  struct MonoInst * D.30906;
  int D.30910;
  struct MonoInst * D.30911;
  int D.30912;
  int D.30913;
  unsigned int D.30914;
  int D.30915;
  int D.30916;
  struct MonoInst * D.30917;
  int D.30918;

  D.30880 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30881 = D.30880 & 64;
  if (D.30881 != 0) goto <D.30882>; else goto <D.30883>;
  <D.30882>:
  if (0 != 0) goto <D.30884>; else goto <D.30885>;
  <D.30884>:
  {
    struct MonoInst * ins;
    struct MonoInst * c;

    D.30880 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.30881 = D.30880 & 64;
    if (D.30881 != 0) goto <D.30886>; else goto <D.30887>;
    <D.30886>:
    D.30888 = cfg->mempool;
    c = mono_mempool_alloc (D.30888, 56);
    c->data.op[1].const_val = 0;
    D.30889 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.30889;
    c->prev = 0B;
    D.30890 = c->prev;
    c->next = D.30890;
    D.30880 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.30881 = D.30880 & 64;
    if (D.30881 != 0) goto <D.30892>; else goto <D.30893>;
    <D.30892>:
    iftmp.83 = 732;
    goto <D.30894>;
    <D.30893>:
    iftmp.83 = 362;
    <D.30894>:
    c->opcode = iftmp.83;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.30895 = c->sreg3;
    c->sreg2 = D.30895;
    D.30896 = c->sreg2;
    c->sreg1 = D.30896;
    D.30897 = cfg->ip;
    c->cil_code = D.30897;
    key.84 = (void *) key;
    c->data.op[0].p = key.84;
    c->data.op[1].src = 48B;
    c->type = 3;
    D.30899 = alloc_dreg (cfg, 3);
    D.30900 = (int) D.30899;
    c->dreg = D.30900;
    goto <D.30901>;
    <D.30887>:
    {
      int _offset;

      _offset = mini_get_tls_offset (key);
      D.30888 = cfg->mempool;
      c = mono_mempool_alloc (D.30888, 56);
      c->data.op[1].const_val = 0;
      D.30889 = c->data.op[1].const_val;
      c->data.op[0].const_val = D.30889;
      c->prev = 0B;
      D.30890 = c->prev;
      c->next = D.30890;
      c->opcode = 362;
      c->flags = 0;
      c->type = 0;
      c->dreg = -1;
      c->sreg3 = -1;
      D.30895 = c->sreg3;
      c->sreg2 = D.30895;
      D.30896 = c->sreg2;
      c->sreg1 = D.30896;
      D.30897 = cfg->ip;
      c->cil_code = D.30897;
      _offset.85 = (void *) _offset;
      c->data.op[0].p = _offset.85;
      c->type = 3;
      D.30903 = alloc_dreg (cfg, 3);
      D.30904 = (int) D.30903;
      c->dreg = D.30904;
    }
    <D.30901>:
    D.30905 = cfg->cbb;
    D.30906 = D.30905->last_ins;
    if (D.30906 != 0B) goto <D.30907>; else goto <D.30908>;
    <D.30907>:
    D.30905 = cfg->cbb;
    D.30906 = D.30905->last_ins;
    D.30906->next = c;
    D.30905 = cfg->cbb;
    D.30906 = D.30905->last_ins;
    c->prev = D.30906;
    D.30905 = cfg->cbb;
    D.30905->last_ins = c;
    goto <D.30909>;
    <D.30908>:
    D.30905 = cfg->cbb;
    D.30905 = cfg->cbb;
    D.30905->last_ins = c;
    D.30906 = D.30905->last_ins;
    D.30905->code = D.30906;
    <D.30909>:
    D.30888 = cfg->mempool;
    ins = mono_mempool_alloc (D.30888, 56);
    ins->data.op[1].const_val = 0;
    D.30910 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.30910;
    ins->prev = 0B;
    D.30911 = ins->prev;
    ins->next = D.30911;
    ins->opcode = 792;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.30912 = ins->sreg3;
    ins->sreg2 = D.30912;
    D.30913 = ins->sreg2;
    ins->sreg1 = D.30913;
    D.30897 = cfg->ip;
    ins->cil_code = D.30897;
    D.30914 = mono_alloc_preg (cfg);
    D.30915 = (int) D.30914;
    ins->dreg = D.30915;
    D.30916 = c->dreg;
    ins->sreg1 = D.30916;
    D.30917 = ins;
    return D.30917;
  }
  <D.30885>:
  D.30917 = 0B;
  return D.30917;
  <D.30883>:
  D.30918 = mini_get_tls_offset (key);
  D.30917 = mono_create_tls_get_offset (cfg, D.30918);
  return D.30917;
}


mono_create_tls_get_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.30922;
  struct MonoMemPool * D.30925;
  int D.30926;
  struct MonoInst * D.30927;
  int D.30928;
  int D.30929;
  const unsigned char * D.30930;
  unsigned int D.30931;
  int D.30932;
  struct MonoInst * ins;

  if (0 != 0) goto <D.30920>; else goto <D.30921>;
  <D.30920>:
  D.30922 = 0B;
  return D.30922;
  <D.30921>:
  if (offset == -1) goto <D.30923>; else goto <D.30924>;
  <D.30923>:
  D.30922 = 0B;
  return D.30922;
  <D.30924>:
  D.30925 = cfg->mempool;
  ins = mono_mempool_alloc (D.30925, 56);
  ins->data.op[1].const_val = 0;
  D.30926 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.30926;
  ins->prev = 0B;
  D.30927 = ins->prev;
  ins->next = D.30927;
  ins->opcode = 791;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.30928 = ins->sreg3;
  ins->sreg2 = D.30928;
  D.30929 = ins->sreg2;
  ins->sreg1 = D.30929;
  D.30930 = cfg->ip;
  ins->cil_code = D.30930;
  D.30931 = mono_alloc_preg (cfg);
  D.30932 = (int) D.30931;
  ins->dreg = D.30932;
  ins->data.op[0].const_val = offset;
  D.30922 = ins;
  return D.30922;
}


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

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


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

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


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

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


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

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


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

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


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

  D.30944 = cfg->mempool;
  ji = mono_mempool_alloc0 (D.30944, 20);
  ji->ip.i = ip;
  ji->type = type;
  ji->data.target = target;
  D.30945 = cfg->patch_info;
  ji->next = D.30945;
  cfg->patch_info = ji;
}


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

  D.30946 = cfg->mempool;
  ji = mono_mempool_alloc0 (D.30946, 20);
  ji->ip.i = ip;
  ji->type = type;
  ji->relocation = relocation;
  ji->data.target = target;
  D.30947 = cfg->patch_info;
  ji->next = D.30947;
  cfg->patch_info = ji;
}


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

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


mono_remove_patch_info (struct MonoCompile * cfg, int ip)
{
  struct MonoJumpInfo * D.30950;
  int D.30951;
  struct MonoJumpInfo * D.30954;
  struct MonoJumpInfo * * ji;

  ji = &cfg->patch_info;
  goto <D.28108>;
  <D.28107>:
  D.30950 = *ji;
  D.30951 = D.30950->ip.i;
  if (D.30951 == ip) goto <D.30952>; else goto <D.30953>;
  <D.30952>:
  D.30950 = *ji;
  D.30954 = D.30950->next;
  *ji = D.30954;
  goto <D.30955>;
  <D.30953>:
  D.30950 = *ji;
  ji = &D.30950->next;
  <D.30955>:
  <D.28108>:
  D.30950 = *ji;
  if (D.30950 != 0B) goto <D.28107>; else goto <D.28109>;
  <D.28109>:
}


mono_patch_info_dup_mp (struct MonoMemPool * mp, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.30956;
  void * D.30957;
  struct MonoJumpInfoToken * D.30958;
  struct MonoJumpInfoToken * D.30959;
  void * D.30960;
  struct MonoJumpInfoBBTable * D.30961;
  struct MonoJumpInfoBBTable * D.30962;
  int D.30963;
  unsigned int D.30964;
  unsigned int D.30965;
  void * D.30966;
  struct MonoBasicBlock * * D.30967;
  struct MonoBasicBlock * * D.30968;
  void * D.30969;
  struct MonoJumpInfoRgctxEntry * D.30970;
  struct MonoJumpInfoRgctxEntry * D.30971;
  struct MonoJumpInfo * D.30972;
  struct MonoJumpInfo * D.30973;
  void * D.30974;
  struct MonoJumpInfoGSharedVtCall * D.30975;
  struct MonoJumpInfoGSharedVtCall * D.30976;
  struct GPtrArray * D.30977;
  struct GPtrArray * D.30978;
  void * * D.30981;
  unsigned int i.86;
  unsigned int D.30983;
  void * * D.30984;
  struct GPtrArray * D.30985;
  unsigned int i.87;
  unsigned int D.30987;
  struct MonoJumpInfo * D.30988;
  struct MonoJumpInfo * res;

  res = mono_mempool_alloc (mp, 20);
  memcpy (res, patch_info, 20);
  D.30956 = patch_info->type;
  switch (D.30956) <default: <D.28133>, case 8: <D.28121>, case 17: <D.28116>, case 18: <D.28118>, case 19: <D.28117>, case 28: <D.28119>, case 29: <D.28115>, case 35: <D.28122>, case 45: <D.28123>, case 46: <D.28124>>
  <D.28115>:
  <D.28116>:
  <D.28117>:
  <D.28118>:
  <D.28119>:
  D.30957 = mono_mempool_alloc (mp, 20);
  res->data.token = D.30957;
  D.30958 = res->data.token;
  D.30959 = patch_info->data.token;
  memcpy (D.30958, D.30959, 20);
  goto <D.28120>;
  <D.28121>:
  D.30960 = mono_mempool_alloc (mp, 8);
  res->data.table = D.30960;
  D.30961 = res->data.table;
  D.30962 = patch_info->data.table;
  memcpy (D.30961, D.30962, 8);
  D.30961 = res->data.table;
  D.30962 = patch_info->data.table;
  D.30963 = D.30962->table_size;
  D.30964 = (unsigned int) D.30963;
  D.30965 = D.30964 * 4;
  D.30966 = mono_mempool_alloc (mp, D.30965);
  D.30961->table = D.30966;
  D.30961 = res->data.table;
  D.30967 = D.30961->table;
  D.30962 = patch_info->data.table;
  D.30968 = D.30962->table;
  D.30962 = patch_info->data.table;
  D.30963 = D.30962->table_size;
  D.30964 = (unsigned int) D.30963;
  D.30965 = D.30964 * 4;
  memcpy (D.30967, D.30968, D.30965);
  goto <D.28120>;
  <D.28122>:
  D.30969 = mono_mempool_alloc (mp, 16);
  res->data.rgctx_entry = D.30969;
  D.30970 = res->data.rgctx_entry;
  D.30971 = patch_info->data.rgctx_entry;
  memcpy (D.30970, D.30971, 16);
  D.30970 = res->data.rgctx_entry;
  D.30970 = res->data.rgctx_entry;
  D.30972 = D.30970->data;
  D.30973 = mono_patch_info_dup_mp (mp, D.30972);
  D.30970->data = D.30973;
  goto <D.28120>;
  <D.28123>:
  D.30974 = mono_mempool_alloc (mp, 8);
  res->data.gsharedvt = D.30974;
  D.30975 = res->data.gsharedvt;
  D.30976 = patch_info->data.gsharedvt;
  memcpy (D.30975, D.30976, 8);
  goto <D.28120>;
  <D.28124>:
  {
    struct MonoGSharedVtMethodInfo * info;
    struct MonoGSharedVtMethodInfo * oinfo;
    int i;

    oinfo = patch_info->data.gsharedvt_method;
    info = mono_mempool_alloc (mp, 8);
    res->data.gsharedvt_method = info;
    memcpy (info, oinfo, 8);
    D.30977 = monoeg_g_ptr_array_new ();
    info->entries = D.30977;
    D.30978 = oinfo->entries;
    if (D.30978 != 0B) goto <D.30979>; else goto <D.30980>;
    <D.30979>:
    i = 0;
    goto <D.28131>;
    <D.28130>:
    {
      struct MonoRuntimeGenericContextInfoTemplate * otemplate;
      struct MonoRuntimeGenericContextInfoTemplate * template;

      D.30978 = oinfo->entries;
      D.30981 = D.30978->pdata;
      i.86 = (unsigned int) i;
      D.30983 = i.86 * 4;
      D.30984 = D.30981 + D.30983;
      otemplate = *D.30984;
      template = mono_mempool_alloc0 (mp, 12);
      memcpy (template, otemplate, 12);
      D.30985 = info->entries;
      monoeg_g_ptr_array_add (D.30985, template);
    }
    i = i + 1;
    <D.28131>:
    i.87 = (unsigned int) i;
    D.30978 = oinfo->entries;
    D.30987 = D.30978->len;
    if (i.87 < D.30987) goto <D.28130>; else goto <D.28132>;
    <D.28132>:
    <D.30980>:
    goto <D.28120>;
  }
  <D.28133>:
  goto <D.28120>;
  <D.28120>:
  D.30988 = res;
  return D.30988;
}


mono_patch_info_hash (const void * data)
{
  <unnamed type> D.30991;
  guint D.30992;
  unsigned int D.30993;
  struct MonoJumpInfoToken * D.30994;
  unsigned int D.30995;
  unsigned int D.30996;
  unsigned int iftmp.88;
  int D.30998;
  struct MonoGenericInst * D.31001;
  const char * D.31003;
  unsigned int D.31004;
  const void * D.31005;
  unsigned int D.31006;
  struct MonoJumpInfoGSharedVtCall * D.31007;
  struct MonoMethod * D.31008;
  unsigned int D.31009;
  struct MonoMethod * D.31010;
  unsigned int D.31011;
  unsigned int D.31012;
  int D.31013;
  unsigned int D.31014;
  unsigned int D.31015;
  <unnamed type> D.31016;
  unsigned int D.31017;
  struct MonoJumpInfo * D.31018;
  unsigned int D.31019;
  struct MonoJumpInfoBBTable * D.31020;
  int D.31021;
  unsigned int D.31022;
  struct MonoGSharedVtMethodInfo * D.31023;
  struct MonoMethod * D.31024;
  unsigned int D.31025;
  const struct MonoJumpInfo * ji;

  ji = data;
  D.30991 = ji->type;
  switch (D.30991) <default: <D.28178>, case 3: <D.28151>, case 4: <D.28152>, case 6: <D.28150>, case 7: <D.28143>, case 8: <D.28175>, case 11: <D.28145>, case 12: <D.28153>, case 13: <D.28156>, case 14: <D.28144>, case 15: <D.28148>, case 16: <D.28157>, case 17: <D.28139>, case 18: <D.28140>, case 19: <D.28142>, case 23: <D.28146>, case 24: <D.28147>, case 27: <D.28174>, case 28: <D.28141>, case 29: <D.28138>, case 30: <D.28160>, case 31: <D.28155>, case 32: <D.28154>, case 33: <D.28167>, case 34: <D.28159>, case 35: <D.28165>, case 36: <D.28149>, case 37: <D.28171>, case 38: <D.28172>, case 39: <D.28168>, case 40: <D.28158>, case 42: <D.28169>, case 43: <D.28173>, case 44: <D.28161>, case 45: <D.28164>, case 46: <D.28176>, case 47: <D.28170>, case 48: <D.28162>, case 49: <D.28177>, case 50: <D.28163>>
  <D.28138>:
  <D.28139>:
  <D.28140>:
  <D.28141>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.30994 = ji->data.token;
  D.30995 = D.30994->token;
  D.30992 = D.30993 | D.30995;
  return D.30992;
  <D.28142>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.30994 = ji->data.token;
  D.30995 = D.30994->token;
  D.30996 = D.30993 | D.30995;
  D.30994 = ji->data.token;
  D.30998 = D.30994->has_context;
  if (D.30998 != 0) goto <D.30999>; else goto <D.31000>;
  <D.30999>:
  D.30994 = ji->data.token;
  D.31001 = D.30994->context.class_inst;
  iftmp.88 = (unsigned int) D.31001;
  goto <D.31002>;
  <D.31000>:
  iftmp.88 = 0;
  <D.31002>:
  D.30992 = D.30996 | iftmp.88;
  return D.30992;
  <D.28143>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.31003 = ji->data.name;
  D.31004 = monoeg_g_str_hash (D.31003);
  D.30992 = D.30993 | D.31004;
  return D.30992;
  <D.28144>:
  <D.28145>:
  <D.28146>:
  <D.28147>:
  <D.28148>:
  <D.28149>:
  <D.28150>:
  <D.28151>:
  <D.28152>:
  <D.28153>:
  <D.28154>:
  <D.28155>:
  <D.28156>:
  <D.28157>:
  <D.28158>:
  <D.28159>:
  <D.28160>:
  <D.28161>:
  <D.28162>:
  <D.28163>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.31005 = ji->data.target;
  D.31006 = (unsigned int) D.31005;
  D.30992 = D.30993 | D.31006;
  return D.30992;
  <D.28164>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.31007 = ji->data.gsharedvt;
  D.31008 = D.31007->method;
  D.31009 = (unsigned int) D.31008;
  D.30992 = D.30993 | D.31009;
  return D.30992;
  <D.28165>:
  {
    struct MonoJumpInfoRgctxEntry * e;

    e = ji->data.rgctx_entry;
    D.30991 = ji->type;
    D.30993 = D.30991 << 8;
    D.31010 = e->method;
    D.31011 = (unsigned int) D.31010;
    D.31012 = D.30993 | D.31011;
    D.31013 = e->in_mrgctx;
    D.31014 = (unsigned int) D.31013;
    D.31015 = D.31012 | D.31014;
    D.31016 = e->info_type;
    D.31017 = D.31015 | D.31016;
    D.31018 = e->data;
    D.31019 = mono_patch_info_hash (D.31018);
    D.30992 = D.31017 | D.31019;
    return D.30992;
  }
  <D.28167>:
  <D.28168>:
  <D.28169>:
  <D.28170>:
  <D.28171>:
  <D.28172>:
  <D.28173>:
  <D.28174>:
  D.30991 = ji->type;
  D.30992 = D.30991 << 8;
  return D.30992;
  <D.28175>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.31020 = ji->data.table;
  D.31021 = D.31020->table_size;
  D.31022 = (unsigned int) D.31021;
  D.30992 = D.30993 | D.31022;
  return D.30992;
  <D.28176>:
  D.30991 = ji->type;
  D.30993 = D.30991 << 8;
  D.31023 = ji->data.gsharedvt_method;
  D.31024 = D.31023->method;
  D.31025 = (unsigned int) D.31024;
  D.30992 = D.30993 | D.31025;
  return D.30992;
  <D.28177>:
  D.31005 = ji->data.target;
  D.30992 = monoeg_g_str_hash (D.31005);
  return D.30992;
  <D.28178>:
  D.30991 = ji->type;
  printf ("info type: %d\n", D.30991);
  mono_print_ji (ji);
  printf ("\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3203);
  D.30992 = 0;
  return D.30992;
}


mono_patch_info_equal (const void * ka, const void * kb)
{
  <unnamed type> D.31027;
  <unnamed type> D.31028;
  gint D.31031;
  struct MonoJumpInfoToken * D.31034;
  struct MonoImage * D.31035;
  struct MonoJumpInfoToken * D.31036;
  struct MonoImage * D.31037;
  unsigned int D.31039;
  unsigned int D.31040;
  int D.31042;
  int D.31043;
  struct MonoGenericInst * D.31045;
  struct MonoGenericInst * D.31046;
  struct MonoGenericInst * D.31048;
  struct MonoGenericInst * D.31049;
  const char * D.31050;
  const char * D.31051;
  int iftmp.89;
  struct MonoMethod * D.31055;
  struct MonoMethod * D.31056;
  int D.31058;
  int D.31059;
  <unnamed type> D.31061;
  <unnamed type> D.31062;
  struct MonoJumpInfo * D.31064;
  struct MonoJumpInfo * D.31065;
  int D.31066;
  int iftmp.90;
  struct MonoMethodSignature * D.31071;
  struct MonoMethodSignature * D.31072;
  struct MonoMethod * D.31074;
  struct MonoMethod * D.31075;
  struct MonoGSharedVtMethodInfo * D.31077;
  struct MonoMethod * D.31078;
  struct MonoGSharedVtMethodInfo * D.31079;
  struct MonoMethod * D.31080;
  _Bool D.31081;
  const void * D.31082;
  const void * D.31083;
  const struct MonoJumpInfo * ji1;
  const struct MonoJumpInfo * ji2;

  ji1 = ka;
  ji2 = kb;
  D.31027 = ji1->type;
  D.31028 = ji2->type;
  if (D.31027 != D.31028) goto <D.31029>; else goto <D.31030>;
  <D.31029>:
  D.31031 = 0;
  return D.31031;
  <D.31030>:
  D.31027 = ji1->type;
  switch (D.31027) <default: <D.28199>, case 7: <D.28191>, case 17: <D.28186>, case 18: <D.28188>, case 19: <D.28187>, case 28: <D.28189>, case 29: <D.28185>, case 35: <D.28192>, case 45: <D.28195>, case 46: <D.28198>>
  <D.28185>:
  <D.28186>:
  <D.28187>:
  <D.28188>:
  <D.28189>:
  D.31034 = ji1->data.token;
  D.31035 = D.31034->image;
  D.31036 = ji2->data.token;
  D.31037 = D.31036->image;
  if (D.31035 != D.31037) goto <D.31032>; else goto <D.31038>;
  <D.31038>:
  D.31034 = ji1->data.token;
  D.31039 = D.31034->token;
  D.31036 = ji2->data.token;
  D.31040 = D.31036->token;
  if (D.31039 != D.31040) goto <D.31032>; else goto <D.31041>;
  <D.31041>:
  D.31034 = ji1->data.token;
  D.31042 = D.31034->has_context;
  D.31036 = ji2->data.token;
  D.31043 = D.31036->has_context;
  if (D.31042 != D.31043) goto <D.31032>; else goto <D.31044>;
  <D.31044>:
  D.31034 = ji1->data.token;
  D.31045 = D.31034->context.class_inst;
  D.31036 = ji2->data.token;
  D.31046 = D.31036->context.class_inst;
  if (D.31045 != D.31046) goto <D.31032>; else goto <D.31047>;
  <D.31047>:
  D.31034 = ji1->data.token;
  D.31048 = D.31034->context.method_inst;
  D.31036 = ji2->data.token;
  D.31049 = D.31036->context.method_inst;
  if (D.31048 != D.31049) goto <D.31032>; else goto <D.31033>;
  <D.31032>:
  D.31031 = 0;
  return D.31031;
  <D.31033>:
  goto <D.28190>;
  <D.28191>:
  D.31050 = ji1->data.name;
  D.31051 = ji2->data.name;
  D.31031 = monoeg_g_str_equal (D.31050, D.31051);
  return D.31031;
  <D.28192>:
  {
    struct MonoJumpInfoRgctxEntry * e1;
    struct MonoJumpInfoRgctxEntry * e2;

    e1 = ji1->data.rgctx_entry;
    e2 = ji2->data.rgctx_entry;
    D.31055 = e1->method;
    D.31056 = e2->method;
    if (D.31055 == D.31056) goto <D.31057>; else goto <D.31053>;
    <D.31057>:
    D.31058 = e1->in_mrgctx;
    D.31059 = e2->in_mrgctx;
    if (D.31058 == D.31059) goto <D.31060>; else goto <D.31053>;
    <D.31060>:
    D.31061 = e1->info_type;
    D.31062 = e2->info_type;
    if (D.31061 == D.31062) goto <D.31063>; else goto <D.31053>;
    <D.31063>:
    D.31064 = e1->data;
    D.31065 = e2->data;
    D.31066 = mono_patch_info_equal (D.31064, D.31065);
    if (D.31066 != 0) goto <D.31067>; else goto <D.31053>;
    <D.31067>:
    iftmp.89 = 1;
    goto <D.31054>;
    <D.31053>:
    iftmp.89 = 0;
    <D.31054>:
    D.31031 = iftmp.89;
    return D.31031;
  }
  <D.28195>:
  {
    struct MonoJumpInfoGSharedVtCall * c1;
    struct MonoJumpInfoGSharedVtCall * c2;

    c1 = ji1->data.gsharedvt;
    c2 = ji2->data.gsharedvt;
    D.31071 = c1->sig;
    D.31072 = c2->sig;
    if (D.31071 == D.31072) goto <D.31073>; else goto <D.31069>;
    <D.31073>:
    D.31074 = c1->method;
    D.31075 = c2->method;
    if (D.31074 == D.31075) goto <D.31076>; else goto <D.31069>;
    <D.31076>:
    iftmp.90 = 1;
    goto <D.31070>;
    <D.31069>:
    iftmp.90 = 0;
    <D.31070>:
    D.31031 = iftmp.90;
    return D.31031;
  }
  <D.28198>:
  D.31077 = ji1->data.gsharedvt_method;
  D.31078 = D.31077->method;
  D.31079 = ji2->data.gsharedvt_method;
  D.31080 = D.31079->method;
  D.31081 = D.31078 == D.31080;
  D.31031 = (gint) D.31081;
  return D.31031;
  <D.28199>:
  D.31082 = ji1->data.target;
  D.31083 = ji2->data.target;
  if (D.31082 != D.31083) goto <D.31084>; else goto <D.31085>;
  <D.31084>:
  D.31031 = 0;
  return D.31031;
  <D.31085>:
  goto <D.28190>;
  <D.28190>:
  D.31031 = 1;
  return D.31031;
}


mono_resolve_patch_target (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * patch_info, gboolean run_cctors)
{
  int D.31087;
  sizetype D.31088;
  <unnamed type> D.31089;
  struct MonoBasicBlock * D.31090;
  int D.31091;
  sizetype D.31092;
  struct MonoInst * D.31093;
  int D.31094;
  sizetype D.31095;
  int D.31096;
  sizetype D.31097;
  const char * D.31098;
  struct MonoMethod * D.31103;
  union mono_mutex_t * D.31107;
  _Bool D.31110;
  long int D.31111;
  long int D.31112;
  void * D.31115;
  struct GHashTable * D.31116;
  struct GHashTable * D.31119;
  _Bool D.31124;
  long int D.31125;
  long int D.31126;
  unsigned char D.31132;
  unsigned char D.31133;
  struct MonoJitDynamicMethodInfo * D.31135;
  struct MonoCodeManager * D.31136;
  struct MonoJumpInfoBBTable * D.31137;
  int D.31138;
  unsigned int D.31139;
  unsigned int D.31140;
  int D.31141;
  int mono_aot_only.91;
  unsigned int i.92;
  unsigned int D.31147;
  void * * D.31148;
  struct MonoBasicBlock * * D.31149;
  struct MonoBasicBlock * * D.31150;
  struct MonoBasicBlock * D.31151;
  sizetype D.31152;
  void * D.31153;
  struct MonoClass * D.31154;
  short unsigned int D.31155;
  int D.31156;
  int D.31157;
  int D.31158;
  _Bool D.31159;
  long int D.31160;
  long int D.31161;
  _Bool D.31164;
  long int D.31165;
  long int D.31166;
  struct MonoClassField * D.31169;
  struct MonoClass * D.31170;
  int D.31171;
  _Bool D.31176;
  long int D.31177;
  long int D.31178;
  struct GHashTable * D.31181;
  _Bool D.31186;
  long int D.31187;
  long int D.31188;
  _Bool D.31191;
  long int D.31192;
  long int D.31193;
  void * D.31196;
  _Bool D.31197;
  long int D.31198;
  long int D.31199;
  unsigned char D.31204;
  unsigned char D.31205;
  struct MonoClass * D.31207;
  unsigned int D.31208;
  unsigned int D.31209;
  int D.31212;
  void * D.31216;
  int D.31217;
  sizetype D.31218;
  struct MonoJumpInfoToken * D.31219;
  unsigned int D.31220;
  struct MonoImage * D.31221;
  unsigned int D.31222;
  unsigned int rva.93;
  unsigned int D.31224;
  struct MonoGenericContext * iftmp.94;
  int D.31226;
  struct MonoClass * handle_class.95;
  struct MonoClass * D.31231;
  struct MonoGenericContext * iftmp.96;
  struct MonoClass * handle_class.97;
  const char * D.31237;
  short unsigned int D.31238;
  int D.31239;
  int D.31240;
  struct MonoImage * D.31249;
  const char * exc_class.98;
  const char * exc_arg.99;
  struct MonoException * D.31252;
  char * D.31253;
  _Bool D.31256;
  _Bool D.31257;
  char * D.31260;
  struct MonoClass * D.31261;
  _Bool D.31262;
  long int D.31263;
  long int D.31264;
  struct MonoGenericContext * D.31267;
  struct MonoGenericInst * D.31268;
  struct MonoJumpInfo * D.31269;
  <unnamed type> D.31270;
  struct MonoMethod * D.31271;
  int D.31272;
  struct MonoClass * D.31273;
  struct MonoType * D.31274;
  <unnamed type> D.31275;
  struct MonoGenericContext * D.31276;
  struct MonoMethod * D.31277;
  struct MonoGenericContext * D.31278;
  struct MonoClassField * D.31279;
  struct MonoGenericContext * D.31280;
  struct MonoMethodSignature * D.31281;
  struct MonoGenericContext * D.31282;
  struct MonoJumpInfoGSharedVtCall * D.31283;
  struct MonoGenericContext * D.31284;
  struct MonoMethod * D.31285;
  struct GPtrArray * D.31286;
  struct GPtrArray * D.31287;
  void * * D.31288;
  unsigned int i.100;
  unsigned int D.31290;
  void * * D.31291;
  struct GPtrArray * D.31292;
  unsigned int i.101;
  unsigned int D.31294;
  struct MonoGenericContext * D.31295;
  int mono_use_llvm.102;
  _Bool D.31300;
  long int D.31301;
  long int D.31302;
  struct MonoJumpInfoImtTramp * D.31305;
  struct MonoMethod * D.31306;
  int D.31307;
  unsigned int mono_jit_tls_id.103;
  const void * D.31309;
  <unnamed type> D.31310;
  unsigned char * ip;
  const void * target;

  D.31087 = patch_info->ip.i;
  D.31088 = (sizetype) D.31087;
  ip = code + D.31088;
  target = 0B;
  D.31089 = patch_info->type;
  switch (D.31089) <default: <D.28307>, case 0: <D.28209>, case 1: <D.28211>, case 2: <D.28212>, case 3: <D.28220>, case 4: <D.28219>, case 5: <D.28214>, case 6: <D.28231>, case 7: <D.28215>, case 8: <D.28225>, case 10: <D.28252>, case 11: <D.28232>, case 12: <D.28233>, case 13: <D.28234>, case 14: <D.28238>, case 15: <D.28239>, case 16: <D.28242>, case 17: <D.28253>, case 18: <D.28257>, case 19: <D.28254>, case 20: <D.28250>, case 21: <D.28251>, case 22: <D.28213>, case 23: <D.28236>, case 24: <D.28237>, case 25: <D.28269>, case 26: <D.28270>, case 27: <D.28271>, case 28: <D.28260>, case 29: <D.28247>, case 30: <D.28241>, case 31: <D.28261>, case 32: <D.28217>, case 33: <D.28266>, case 34: <D.28267>, case 35: <D.28273>, case 36: <D.28294>, case 37: <D.28295>, case 38: <D.28296>, case 40: <D.28297>, case 41: <D.28298>, case 42: <D.28299>, case 43: <D.28302>, case 44: <D.28235>, case 47: <D.28303>, case 48: <D.28304>, case 49: <D.28306>, case 50: <D.28221>, case 51: <D.28272>>
  <D.28209>:
  D.31090 = patch_info->data.bb;
  D.31091 = D.31090->native_offset;
  D.31092 = (sizetype) D.31091;
  target = code + D.31092;
  goto <D.28210>;
  <D.28211>:
  target = patch_info->data.target;
  goto <D.28210>;
  <D.28212>:
  D.31093 = patch_info->data.inst;
  D.31094 = D.31093->data.op[0].const_val;
  D.31095 = (sizetype) D.31094;
  target = code + D.31095;
  goto <D.28210>;
  <D.28213>:
  target = ip;
  goto <D.28210>;
  <D.28214>:
  D.31096 = patch_info->data.offset;
  D.31097 = (sizetype) D.31096;
  target = code + D.31097;
  goto <D.28210>;
  <D.28215>:
  {
    struct MonoJitICallInfo * mi;

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

    D.31098 = patch_info->data.name;
    mi = mono_find_jit_icall_by_name (D.31098);
    if (mi == 0B) goto <D.31101>; else goto <D.31102>;
    <D.31101>:
    D.31098 = patch_info->data.name;
    monoeg_g_log (0B, 16, "unknown MONO_PATCH_INFO_JIT_ICALL_ADDR %s", D.31098);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3308);
    <D.31102>:
    target = mi->func;
    goto <D.28210>;
  }
  <D.28219>:
  D.31103 = patch_info->data.method;
  target = mono_create_jump_trampoline (domain, D.31103, 0);
  goto <D.28210>;
  <D.28220>:
  D.31103 = patch_info->data.method;
  if (D.31103 == method) goto <D.31104>; else goto <D.31105>;
  <D.31104>:
  target = code;
  goto <D.31106>;
  <D.31105>:
  D.31103 = patch_info->data.method;
  target = mono_create_jit_trampoline_in_domain (domain, D.31103);
  <D.31106>:
  goto <D.28210>;
  <D.28221>:
  {
    void * code_slot;

    {
      int ret;

      D.31107 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.31107);
      if (ret != 0) goto <D.31108>; else goto <D.31109>;
      <D.31108>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.31109>:
      D.31110 = ret != 0;
      D.31111 = (long int) D.31110;
      D.31112 = __builtin_expect (D.31111, 0);
      if (D.31112 != 0) goto <D.31113>; else goto <D.31114>;
      <D.31113>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3343, "ret == 0");
      <D.31114>:
    }
    D.31115 = domain->runtime_info;
    D.31116 = MEM[(struct MonoJitDomainInfo *)D.31115].method_code_hash;
    if (D.31116 == 0B) goto <D.31117>; else goto <D.31118>;
    <D.31117>:
    D.31115 = domain->runtime_info;
    D.31119 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.31115].method_code_hash = D.31119;
    <D.31118>:
    D.31115 = domain->runtime_info;
    D.31116 = MEM[(struct MonoJitDomainInfo *)D.31115].method_code_hash;
    D.31103 = patch_info->data.method;
    code_slot = monoeg_g_hash_table_lookup (D.31116, D.31103);
    if (code_slot == 0B) goto <D.31120>; else goto <D.31121>;
    <D.31120>:
    code_slot = mono_domain_alloc0 (domain, 4);
    D.31115 = domain->runtime_info;
    D.31116 = MEM[(struct MonoJitDomainInfo *)D.31115].method_code_hash;
    D.31103 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.31116, D.31103, code_slot, 0);
    <D.31121>:
    {
      int ret;

      D.31107 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.31107);
      if (ret != 0) goto <D.31122>; else goto <D.31123>;
      <D.31122>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.31123>:
      D.31124 = ret != 0;
      D.31125 = (long int) D.31124;
      D.31126 = __builtin_expect (D.31125, 0);
      if (D.31126 != 0) goto <D.31127>; else goto <D.31128>;
      <D.31127>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3351, "ret == 0");
      <D.31128>:
    }
    target = code_slot;
    goto <D.28210>;
  }
  <D.28225>:
  {
    void * * jump_table;
    int i;

    if (method != 0B) goto <D.31131>; else goto <D.31129>;
    <D.31131>:
    D.31132 = BIT_FIELD_REF <*method, 8, 168>;
    D.31133 = D.31132 & 2;
    if (D.31133 != 0) goto <D.31134>; else goto <D.31129>;
    <D.31134>:
    D.31135 = mono_dynamic_code_hash_lookup (domain, method);
    D.31136 = D.31135->code_mp;
    D.31137 = patch_info->data.table;
    D.31138 = D.31137->table_size;
    D.31139 = (unsigned int) D.31138;
    D.31140 = D.31139 * 4;
    D.31141 = (int) D.31140;
    jump_table = mono_code_manager_reserve (D.31136, D.31141);
    goto <D.31130>;
    <D.31129>:
    mono_aot_only.91 = mono_aot_only;
    if (mono_aot_only.91 != 0) goto <D.31143>; else goto <D.31144>;
    <D.31143>:
    D.31137 = patch_info->data.table;
    D.31138 = D.31137->table_size;
    D.31139 = (unsigned int) D.31138;
    D.31140 = D.31139 * 4;
    jump_table = mono_domain_alloc (domain, D.31140);
    goto <D.31145>;
    <D.31144>:
    D.31137 = patch_info->data.table;
    D.31138 = D.31137->table_size;
    D.31139 = (unsigned int) D.31138;
    D.31140 = D.31139 * 4;
    D.31141 = (int) D.31140;
    jump_table = mono_domain_code_reserve (domain, D.31141);
    <D.31145>:
    <D.31130>:
    i = 0;
    goto <D.28229>;
    <D.28228>:
    i.92 = (unsigned int) i;
    D.31147 = i.92 * 4;
    D.31148 = jump_table + D.31147;
    D.31137 = patch_info->data.table;
    D.31149 = D.31137->table;
    i.92 = (unsigned int) i;
    D.31147 = i.92 * 4;
    D.31150 = D.31149 + D.31147;
    D.31151 = *D.31150;
    D.31152 = (sizetype) D.31151;
    D.31153 = code + D.31152;
    *D.31148 = D.31153;
    i = i + 1;
    <D.28229>:
    D.31137 = patch_info->data.table;
    D.31138 = D.31137->table_size;
    if (D.31138 > i) goto <D.28228>; else goto <D.28230>;
    <D.28230>:
    target = jump_table;
    goto <D.28210>;
  }
  <D.28231>:
  <D.28232>:
  <D.28233>:
  <D.28234>:
  <D.28235>:
  target = patch_info->data.target;
  goto <D.28210>;
  <D.28236>:
  D.31154 = patch_info->data.klass;
  mono_class_init (D.31154);
  D.31154 = patch_info->data.klass;
  D.31155 = D.31154->interface_id;
  D.31156 = (int) D.31155;
  target = (const void *) D.31156;
  goto <D.28210>;
  <D.28237>:
  D.31154 = patch_info->data.klass;
  mono_class_init (D.31154);
  D.31154 = patch_info->data.klass;
  D.31155 = D.31154->interface_id;
  D.31156 = (int) D.31155;
  D.31157 = ~D.31156;
  D.31158 = D.31157 * 4;
  target = (const void *) D.31158;
  goto <D.28210>;
  <D.28238>:
  D.31154 = patch_info->data.klass;
  target = mono_class_vtable (domain, D.31154);
  D.31159 = target == 0B;
  D.31160 = (long int) D.31159;
  D.31161 = __builtin_expect (D.31160, 0);
  if (D.31161 != 0) goto <D.31162>; else goto <D.31163>;
  <D.31162>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3412, "target");
  <D.31163>:
  goto <D.28210>;
  <D.28239>:
  {
    struct MonoVTable * vtable;

    D.31154 = patch_info->data.klass;
    vtable = mono_class_vtable (domain, D.31154);
    D.31164 = vtable == 0B;
    D.31165 = (long int) D.31164;
    D.31166 = __builtin_expect (D.31165, 0);
    if (D.31166 != 0) goto <D.31167>; else goto <D.31168>;
    <D.31167>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3417, "vtable");
    <D.31168>:
    target = mono_create_class_init_trampoline (vtable);
    goto <D.28210>;
  }
  <D.28241>:
  D.31154 = patch_info->data.klass;
  target = mono_create_delegate_trampoline (domain, D.31154);
  goto <D.28210>;
  <D.28242>:
  {
    struct MonoVTable * vtable;

    D.31169 = patch_info->data.field;
    D.31170 = D.31169->parent;
    vtable = mono_class_vtable (domain, D.31170);
    D.31169 = patch_info->data.field;
    D.31171 = mono_class_field_is_special_static (D.31169);
    if (D.31171 != 0) goto <D.31172>; else goto <D.31173>;
    <D.31172>:
    {
      void * addr;

      addr = 0B;
      {
        int ret;

        D.31107 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.31107);
        if (ret != 0) goto <D.31174>; else goto <D.31175>;
        <D.31174>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31175>:
        D.31176 = ret != 0;
        D.31177 = (long int) D.31176;
        D.31178 = __builtin_expect (D.31177, 0);
        if (D.31178 != 0) goto <D.31179>; else goto <D.31180>;
        <D.31179>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3430, "ret == 0");
        <D.31180>:
      }
      D.31181 = domain->special_static_fields;
      if (D.31181 != 0B) goto <D.31182>; else goto <D.31183>;
      <D.31182>:
      D.31181 = domain->special_static_fields;
      D.31169 = patch_info->data.field;
      addr = monoeg_g_hash_table_lookup (D.31181, D.31169);
      <D.31183>:
      {
        int ret;

        D.31107 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.31107);
        if (ret != 0) goto <D.31184>; else goto <D.31185>;
        <D.31184>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31185>:
        D.31186 = ret != 0;
        D.31187 = (long int) D.31186;
        D.31188 = __builtin_expect (D.31187, 0);
        if (D.31188 != 0) goto <D.31189>; else goto <D.31190>;
        <D.31189>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3433, "ret == 0");
        <D.31190>:
      }
      D.31191 = addr == 0B;
      D.31192 = (long int) D.31191;
      D.31193 = __builtin_expect (D.31192, 0);
      if (D.31193 != 0) goto <D.31194>; else goto <D.31195>;
      <D.31194>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3434, "addr");
      <D.31195>:
      D.31196 = addr;
      return D.31196;
    }
    <D.31173>:
    D.31197 = vtable == 0B;
    D.31198 = (long int) D.31197;
    D.31199 = __builtin_expect (D.31198, 0);
    if (D.31199 != 0) goto <D.31200>; else goto <D.31201>;
    <D.31200>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3438, "vtable");
    <D.31201>:
    D.31204 = BIT_FIELD_REF <*vtable, 8, 184>;
    D.31205 = D.31204 & 2;
    if (D.31205 == 0) goto <D.31206>; else goto <D.31202>;
    <D.31206>:
    D.31207 = vtable->klass;
    D.31208 = D.31207->flags;
    D.31209 = D.31208 & 1048576;
    if (D.31209 == 0) goto <D.31210>; else goto <D.31202>;
    <D.31210>:
    if (method != 0B) goto <D.31211>; else goto <D.31202>;
    <D.31211>:
    D.31207 = vtable->klass;
    D.31212 = mono_class_needs_cctor_run (D.31207, method);
    if (D.31212 != 0) goto <D.31213>; else goto <D.31202>;
    <D.31213>:
    goto <D.31203>;
    <D.31202>:
    if (run_cctors != 0) goto <D.31214>; else goto <D.31215>;
    <D.31214>:
    mono_runtime_class_init (vtable);
    <D.31215>:
    <D.31203>:
    D.31216 = mono_vtable_get_static_field_data (vtable);
    D.31169 = patch_info->data.field;
    D.31217 = D.31169->offset;
    D.31218 = (sizetype) D.31217;
    target = D.31216 + D.31218;
    goto <D.28210>;
  }
  <D.28247>:
  {
    guint32 field_index;
    guint32 rva;

    try
      {
        D.31219 = patch_info->data.token;
        D.31220 = D.31219->token;
        field_index = D.31220 & 16777215;
        D.31219 = patch_info->data.token;
        D.31221 = D.31219->image;
        D.31222 = field_index + 4294967295;
        mono_metadata_field_info (D.31221, D.31222, 0B, &rva, 0B);
        D.31219 = patch_info->data.token;
        D.31221 = D.31219->image;
        rva.93 = rva;
        target = mono_image_rva_map (D.31221, rva.93);
        goto <D.28210>;
      }
    finally
      {
        rva = {CLOBBER};
      }
  }
  <D.28250>:
  <D.28251>:
  target = patch_info->data.target;
  goto <D.28210>;
  <D.28252>:
  target = patch_info->data.name;
  goto <D.28210>;
  <D.28253>:
  D.31219 = patch_info->data.token;
  D.31221 = D.31219->image;
  D.31219 = patch_info->data.token;
  D.31220 = D.31219->token;
  D.31224 = D.31220 & 16777215;
  target = mono_ldstr (domain, D.31221, D.31224);
  goto <D.28210>;
  <D.28254>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.31219 = patch_info->data.token;
        D.31221 = D.31219->image;
        D.31219 = patch_info->data.token;
        D.31220 = D.31219->token;
        D.31219 = patch_info->data.token;
        D.31226 = D.31219->has_context;
        if (D.31226 != 0) goto <D.31227>; else goto <D.31228>;
        <D.31227>:
        D.31219 = patch_info->data.token;
        iftmp.94 = &D.31219->context;
        goto <D.31229>;
        <D.31228>:
        iftmp.94 = 0B;
        <D.31229>:
        handle = mono_ldtoken (D.31221, D.31220, &handle_class, iftmp.94);
        handle_class.95 = handle_class;
        mono_class_init (handle_class.95);
        D.31231 = mono_class_from_mono_type (handle);
        mono_class_init (D.31231);
        target = mono_type_get_object (domain, handle);
        goto <D.28210>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.28257>:
  {
    void * handle;
    struct MonoClass * handle_class;

    try
      {
        D.31219 = patch_info->data.token;
        D.31221 = D.31219->image;
        D.31219 = patch_info->data.token;
        D.31220 = D.31219->token;
        D.31219 = patch_info->data.token;
        D.31226 = D.31219->has_context;
        if (D.31226 != 0) goto <D.31233>; else goto <D.31234>;
        <D.31233>:
        D.31219 = patch_info->data.token;
        iftmp.96 = &D.31219->context;
        goto <D.31235>;
        <D.31234>:
        iftmp.96 = 0B;
        <D.31235>:
        handle = mono_ldtoken (D.31221, D.31220, &handle_class, iftmp.96);
        handle_class.97 = handle_class;
        mono_class_init (handle_class.97);
        target = handle;
        goto <D.28210>;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
  <D.28260>:
  D.31219 = patch_info->data.token;
  D.31221 = D.31219->image;
  D.31219 = patch_info->data.token;
  D.31220 = D.31219->token;
  D.31237 = mono_metadata_blob_heap (D.31221, D.31220);
  target = D.31237 + 2;
  goto <D.28210>;
  <D.28261>:
  D.31103 = patch_info->data.method;
  D.31238 = D.31103->flags;
  D.31239 = (int) D.31238;
  D.31240 = D.31239 & 8192;
  if (D.31240 != 0) goto <D.31241>; else goto <D.31242>;
  <D.31241>:
  {
    const char * exc_class;
    const char * exc_arg;

    try
      {
        if (run_cctors != 0) goto <D.31243>; else goto <D.31244>;
        <D.31243>:
        D.31103 = patch_info->data.method;
        target = mono_lookup_pinvoke_call (D.31103, &exc_class, &exc_arg);
        if (target == 0B) goto <D.31245>; else goto <D.31246>;
        <D.31245>:
        mono_aot_only.91 = mono_aot_only;
        if (mono_aot_only.91 != 0) goto <D.31247>; else goto <D.31248>;
        <D.31247>:
        D.31249 = mono_defaults.corlib;
        exc_class.98 = exc_class;
        exc_arg.99 = exc_arg;
        D.31252 = mono_exception_from_name_msg (D.31249, "System", exc_class.98, exc_arg.99);
        mono_raise_exception (D.31252);
        <D.31248>:
        D.31103 = patch_info->data.method;
        D.31253 = mono_method_full_name (D.31103, 1);
        monoeg_g_log (0B, 4, "Unable to resolve pinvoke method \'%s\' Re-run with MONO_LOG_LEVEL=debug for more information.\n", D.31253);
        <D.28264>:
        goto <D.28264>;
        <D.31246>:
        goto <D.31254>;
        <D.31244>:
        target = 0B;
        <D.31254>:
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  goto <D.31255>;
  <D.31242>:
  D.31103 = patch_info->data.method;
  target = mono_lookup_internal_call (D.31103);
  D.31159 = target == 0B;
  D.31256 = run_cctors != 0;
  D.31257 = D.31159 & D.31256;
  if (D.31257 != 0) goto <D.31258>; else goto <D.31259>;
  <D.31258>:
  D.31103 = patch_info->data.method;
  D.31260 = mono_method_full_name (D.31103, 1);
  monoeg_g_log (0B, 4, "Unregistered icall \'%s\'\n", D.31260);
  <D.28265>:
  goto <D.28265>;
  <D.31259>:
  <D.31255>:
  goto <D.28210>;
  <D.28266>:
  target = mono_thread_interruption_request_flag ();
  goto <D.28210>;
  <D.28267>:
  {
    struct MonoVTable * vtable;

    D.31103 = patch_info->data.method;
    D.31261 = D.31103->klass;
    vtable = mono_class_vtable (domain, D.31261);
    D.31262 = vtable == 0B;
    D.31263 = (long int) D.31262;
    D.31264 = __builtin_expect (D.31263, 0);
    if (D.31264 != 0) goto <D.31265>; else goto <D.31266>;
    <D.31265>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3524, "vtable");
    <D.31266>:
    D.31103 = patch_info->data.method;
    D.31267 = mini_method_get_context (D.31103);
    D.31268 = D.31267->method_inst;
    target = mono_method_lookup_rgctx (vtable, D.31268);
    goto <D.28210>;
  }
  <D.28269>:
  <D.28270>:
  <D.28271>:
  <D.28272>:
  goto <D.28210>;
  <D.28273>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    guint32 slot;

    entry = patch_info->data.rgctx_entry;
    slot = 4294967295;
    D.31269 = entry->data;
    D.31270 = D.31269->type;
    switch (D.31270) <default: <D.28293>, case 3: <D.28278>, case 6: <D.28279>, case 11: <D.28276>, case 13: <D.28280>, case 44: <D.28281>, case 45: <D.28282>, case 46: <D.28284>>
    <D.28276>:
    D.31271 = entry->method;
    D.31272 = entry->in_mrgctx;
    D.31269 = entry->data;
    D.31273 = D.31269->data.klass;
    D.31274 = &D.31273->byval_arg;
    D.31275 = entry->info_type;
    D.31271 = entry->method;
    D.31276 = mono_method_get_context (D.31271);
    slot = mono_method_lookup_or_register_info (D.31271, D.31272, D.31274, D.31275, D.31276);
    goto <D.28277>;
    <D.28278>:
    <D.28279>:
    D.31271 = entry->method;
    D.31272 = entry->in_mrgctx;
    D.31269 = entry->data;
    D.31277 = D.31269->data.method;
    D.31275 = entry->info_type;
    D.31271 = entry->method;
    D.31278 = mono_method_get_context (D.31271);
    slot = mono_method_lookup_or_register_info (D.31271, D.31272, D.31277, D.31275, D.31278);
    goto <D.28277>;
    <D.28280>:
    D.31271 = entry->method;
    D.31272 = entry->in_mrgctx;
    D.31269 = entry->data;
    D.31279 = D.31269->data.field;
    D.31275 = entry->info_type;
    D.31271 = entry->method;
    D.31280 = mono_method_get_context (D.31271);
    slot = mono_method_lookup_or_register_info (D.31271, D.31272, D.31279, D.31275, D.31280);
    goto <D.28277>;
    <D.28281>:
    D.31271 = entry->method;
    D.31272 = entry->in_mrgctx;
    D.31269 = entry->data;
    D.31281 = D.31269->data.sig;
    D.31275 = entry->info_type;
    D.31271 = entry->method;
    D.31282 = mono_method_get_context (D.31271);
    slot = mono_method_lookup_or_register_info (D.31271, D.31272, D.31281, D.31275, D.31282);
    goto <D.28277>;
    <D.28282>:
    {
      struct MonoJumpInfoGSharedVtCall * call_info;

      call_info = monoeg_malloc0 (8);
      D.31269 = entry->data;
      D.31283 = D.31269->data.gsharedvt;
      memcpy (call_info, D.31283, 8);
      D.31271 = entry->method;
      D.31272 = entry->in_mrgctx;
      D.31275 = entry->info_type;
      D.31271 = entry->method;
      D.31284 = mono_method_get_context (D.31271);
      slot = mono_method_lookup_or_register_info (D.31271, D.31272, call_info, D.31275, D.31284);
      goto <D.28277>;
    }
    <D.28284>:
    {
      struct MonoGSharedVtMethodInfo * info;
      struct MonoGSharedVtMethodInfo * oinfo;
      int i;

      D.31269 = entry->data;
      oinfo = D.31269->data.gsharedvt_method;
      info = monoeg_malloc0 (8);
      D.31285 = oinfo->method;
      info->method = D.31285;
      D.31286 = monoeg_g_ptr_array_new ();
      info->entries = D.31286;
      i = 0;
      goto <D.28291>;
      <D.28290>:
      {
        struct MonoRuntimeGenericContextInfoTemplate * otemplate;
        struct MonoRuntimeGenericContextInfoTemplate * template;

        D.31287 = oinfo->entries;
        D.31288 = D.31287->pdata;
        i.100 = (unsigned int) i;
        D.31290 = i.100 * 4;
        D.31291 = D.31288 + D.31290;
        otemplate = *D.31291;
        template = monoeg_malloc0 (12);
        memcpy (template, otemplate, 12);
        D.31292 = info->entries;
        monoeg_g_ptr_array_add (D.31292, template);
      }
      i = i + 1;
      <D.28291>:
      i.101 = (unsigned int) i;
      D.31287 = oinfo->entries;
      D.31294 = D.31287->len;
      if (i.101 < D.31294) goto <D.28290>; else goto <D.28292>;
      <D.28292>:
      D.31271 = entry->method;
      D.31272 = entry->in_mrgctx;
      D.31275 = entry->info_type;
      D.31271 = entry->method;
      D.31295 = mono_method_get_context (D.31271);
      slot = mono_method_lookup_or_register_info (D.31271, D.31272, info, D.31275, D.31295);
      goto <D.28277>;
    }
    <D.28293>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3579);
    <D.28277>:
    target = mono_create_rgctx_lazy_fetch_trampoline (slot);
    goto <D.28210>;
  }
  <D.28294>:
  target = mono_create_generic_class_init_trampoline ();
  goto <D.28210>;
  <D.28295>:
  target = mono_create_monitor_enter_trampoline ();
  goto <D.28210>;
  <D.28296>:
  target = mono_create_monitor_exit_trampoline ();
  goto <D.28210>;
  <D.28297>:
  if (run_cctors == 0) goto <D.31296>; else goto <D.31297>;
  <D.31296>:
  target = 0B;
  goto <D.31298>;
  <D.31297>:
  target = mono_arch_get_seq_point_info (domain, code);
  <D.31298>:
  goto <D.28210>;
  <D.28298>:
  mono_use_llvm.102 = mono_use_llvm;
  D.31300 = mono_use_llvm.102 == 0;
  D.31301 = (long int) D.31300;
  D.31302 = __builtin_expect (D.31301, 0);
  if (D.31302 != 0) goto <D.31303>; else goto <D.31304>;
  <D.31303>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3606, "mono_use_llvm");
  <D.31304>:
  D.31305 = patch_info->data.imt_tramp;
  D.31306 = D.31305->method;
  D.31305 = patch_info->data.imt_tramp;
  D.31307 = D.31305->vt_offset;
  target = mono_create_llvm_imt_trampoline (domain, D.31306, D.31307);
  goto <D.28210>;
  <D.28299>:
  {
    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.28210>;
      }
    finally
      {
        card_table_shift_bits = {CLOBBER};
        card_table_mask = {CLOBBER};
      }
  }
  <D.28302>:
  target = mono_domain_alloc0 (domain, 4);
  goto <D.28210>;
  <D.28303>:
  mono_jit_tls_id.103 = mono_jit_tls_id;
  target = (const void *) mono_jit_tls_id.103;
  goto <D.28210>;
  <D.28304>:
  {
    int offset;

    D.31309 = patch_info->data.target;
    D.31310 = (<unnamed type>) D.31309;
    offset = mini_get_tls_offset (D.31310);
    target = (const void *) offset;
    goto <D.28210>;
  }
  <D.28306>:
  target = 0B;
  goto <D.28210>;
  <D.28307>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 3642);
  <D.28210>:
  D.31196 = target;
  return D.31196;
}


mono_dynamic_code_hash_lookup (struct MonoDomain * domain, struct MonoMethod * method)
{
  void * D.31317;
  struct GHashTable * D.31318;
  struct MonoJitDynamicMethodInfo * D.31322;
  struct MonoJitDynamicMethodInfo * res;

  D.31317 = domain->runtime_info;
  D.31318 = MEM[(struct MonoJitDomainInfo *)D.31317].dynamic_code_hash;
  if (D.31318 != 0B) goto <D.31319>; else goto <D.31320>;
  <D.31319>:
  D.31317 = domain->runtime_info;
  D.31318 = MEM[(struct MonoJitDomainInfo *)D.31317].dynamic_code_hash;
  res = monoeg_g_hash_table_lookup (D.31318, method);
  goto <D.31321>;
  <D.31320>:
  res = 0B;
  <D.31321>:
  D.31322 = res;
  return D.31322;
}


mono_add_seq_point (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, int native_offset)
{
  struct GPtrArray * D.31324;
  struct MonoMemPool * D.31327;
  struct GSList * D.31328;
  struct GSList * D.31329;

  ins->data.op[0].const_val = native_offset;
  D.31324 = cfg->seq_points;
  monoeg_g_ptr_array_add (D.31324, ins);
  if (bb != 0B) goto <D.31325>; else goto <D.31326>;
  <D.31325>:
  D.31327 = cfg->mempool;
  D.31328 = bb->seq_points;
  D.31329 = g_slist_prepend_mempool (D.31327, D.31328, ins);
  bb->seq_points = D.31329;
  bb->last_seq_point = ins;
  <D.31326>:
}


mono_add_var_location (struct MonoCompile * cfg, struct MonoInst * var, gboolean is_reg, int reg, int offset, int from, int to)
{
  struct MonoMemPool * D.31330;
  _Bool D.31333;
  long int D.31334;
  long int D.31335;
  struct MonoInst * * D.31338;
  struct MonoInst * D.31339;
  struct GSList * D.31342;
  struct GSList * D.31343;
  struct MonoInst * D.31345;
  struct GSList * D.31348;
  struct GSList * D.31349;
  struct MonoDwarfLocListEntry * entry;

  D.31330 = cfg->mempool;
  entry = mono_mempool_alloc0 (D.31330, 20);
  if (is_reg != 0) goto <D.31331>; else goto <D.31332>;
  <D.31331>:
  D.31333 = offset != 0;
  D.31334 = (long int) D.31333;
  D.31335 = __builtin_expect (D.31334, 0);
  if (D.31335 != 0) goto <D.31336>; else goto <D.31337>;
  <D.31336>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3665, "offset == 0");
  <D.31337>:
  <D.31332>:
  entry->is_reg = is_reg;
  entry->reg = reg;
  entry->offset = offset;
  entry->from = from;
  entry->to = to;
  D.31338 = cfg->args;
  D.31339 = *D.31338;
  if (D.31339 == var) goto <D.31340>; else goto <D.31341>;
  <D.31340>:
  D.31330 = cfg->mempool;
  D.31342 = cfg->this_loclist;
  D.31343 = g_slist_append_mempool (D.31330, D.31342, entry);
  cfg->this_loclist = D.31343;
  goto <D.31344>;
  <D.31341>:
  D.31345 = cfg->rgctx_var;
  if (D.31345 == var) goto <D.31346>; else goto <D.31347>;
  <D.31346>:
  D.31330 = cfg->mempool;
  D.31348 = cfg->rgctx_loclist;
  D.31349 = g_slist_append_mempool (D.31330, D.31348, entry);
  cfg->rgctx_loclist = D.31349;
  <D.31347>:
  <D.31344>:
}


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

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


mono_codegen (struct MonoCompile * cfg)
{
  int mono_using_xdebug.104;
  unsigned int D.31354;
  unsigned int D.31355;
  unsigned char D.31358;
  unsigned char D.31359;
  unsigned int D.31364;
  unsigned int D.31365;
  struct MonoMethod * D.31368;
  unsigned int D.31369;
  int D.31370;
  struct MonoProfileCoverageInfo * D.31371;
  unsigned int D.31372;
  int code.105;
  unsigned char * D.31376;
  int D.31377;
  int D.31378;
  unsigned int D.31379;
  unsigned int D.31380;
  int D.31381;
  int D.31382;
  unsigned int D.31383;
  unsigned int D.31384;
  int D.31385;
  struct MonoBasicBlock * D.31386;
  unsigned int D.31391;
  _Bool D.31392;
  long int D.31393;
  long int D.31394;
  unsigned int max_epilog_size.106;
  unsigned int D.31398;
  unsigned char D.31399;
  unsigned char D.31400;
  void * D.31403;
  struct MonoJitDynamicMethodInfo * D.31404;
  struct MonoCodeManager * D.31405;
  struct MonoDomain * D.31406;
  union mono_mutex_t * D.31407;
  _Bool D.31410;
  long int D.31411;
  long int D.31412;
  _Bool D.31417;
  long int D.31418;
  long int D.31419;
  unsigned int D.31424;
  int D.31425;
  struct MonoCodeManager * D.31427;
  unsigned int D.31429;
  int D.31430;
  _Bool D.31431;
  long int D.31432;
  long int D.31433;
  unsigned int D.31436;
  unsigned char * D.31439;
  char * D.31440;
  unsigned char D.31443;
  struct MonoGenericContainer * D.31445;
  struct MonoClass * D.31447;
  struct MonoGenericContainer * D.31448;
  struct MonoGenericClass * D.31450;
  struct MonoGenericSharingContext * D.31451;
  _Bool D.31454;
  long int D.31455;
  long int D.31456;
  struct MonoJumpInfo * D.31459;
  struct MonoCodeManager * iftmp.107;
  <unnamed-unsigned:1> D.31464;
  int D.31465;
  int D.31470;
  int D.31473;
  struct MonoBasicBlock * bb;
  int max_epilog_size;
  guint8 * code;
  struct MonoDomain * code_domain;

  mono_using_xdebug.104 = mono_using_xdebug;
  if (mono_using_xdebug.104 != 0) goto <D.31351>; else goto <D.31352>;
  <D.31351>:
  code_domain = mono_get_root_domain ();
  goto <D.31353>;
  <D.31352>:
  code_domain = cfg->domain;
  <D.31353>:
  bb = cfg->bb_entry;
  goto <D.28443>;
  <D.28442>:
  cfg->spill_count = 0;
  mono_arch_lowering_pass (cfg, bb);
  D.31354 = cfg->opt;
  D.31355 = D.31354 & 1;
  if (D.31355 != 0) goto <D.31356>; else goto <D.31357>;
  <D.31356>:
  mono_arch_peephole_pass_1 (cfg, bb);
  <D.31357>:
  D.31358 = BIT_FIELD_REF <*cfg, 8, 3400>;
  D.31359 = D.31358 & 16;
  if (D.31359 == 0) goto <D.31360>; else goto <D.31361>;
  <D.31360>:
  mono_local_regalloc (cfg, bb);
  <D.31361>:
  D.31354 = cfg->opt;
  D.31355 = D.31354 & 1;
  if (D.31355 != 0) goto <D.31362>; else goto <D.31363>;
  <D.31362>:
  mono_arch_peephole_pass_2 (cfg, bb);
  <D.31363>:
  bb = bb->next_bb;
  <D.28443>:
  if (bb != 0B) goto <D.28442>; else goto <D.28444>;
  <D.28444>:
  D.31364 = cfg->prof_options;
  D.31365 = D.31364 & 8192;
  if (D.31365 != 0) goto <D.31366>; else goto <D.31367>;
  <D.31366>:
  D.31368 = cfg->method;
  D.31369 = cfg->num_bblocks;
  D.31370 = (int) D.31369;
  D.31371 = mono_profiler_coverage_alloc (D.31368, D.31370);
  cfg->coverage_info = D.31371;
  <D.31367>:
  code = mono_arch_emit_prolog (cfg);
  D.31364 = cfg->prof_options;
  D.31372 = D.31364 & 4096;
  if (D.31372 != 0) goto <D.31373>; else goto <D.31374>;
  <D.31373>:
  code = mono_arch_instrument_prolog (cfg, mono_profiler_method_enter, code, 0);
  <D.31374>:
  code.105 = (int) code;
  D.31376 = cfg->native_code;
  D.31377 = (int) D.31376;
  D.31378 = code.105 - D.31377;
  D.31379 = (unsigned int) D.31378;
  cfg->code_len = D.31379;
  D.31380 = cfg->code_len;
  cfg->prolog_end = D.31380;
  mono_debug_open_method (cfg);
  bb = cfg->bb_entry;
  goto <D.28446>;
  <D.28445>:
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  bb->native_offset = D.31381;
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  bb->real_native_offset = D.31381;
  mono_arch_output_basic_block (cfg, bb);
  D.31380 = cfg->code_len;
  D.31382 = bb->native_offset;
  D.31383 = (unsigned int) D.31382;
  D.31384 = D.31380 - D.31383;
  D.31385 = (int) D.31384;
  bb->native_length = D.31385;
  D.31386 = cfg->bb_exit;
  if (D.31386 == bb) goto <D.31387>; else goto <D.31388>;
  <D.31387>:
  D.31380 = cfg->code_len;
  cfg->epilog_begin = D.31380;
  D.31364 = cfg->prof_options;
  D.31372 = D.31364 & 4096;
  if (D.31372 != 0) goto <D.31389>; else goto <D.31390>;
  <D.31389>:
  D.31376 = cfg->native_code;
  D.31380 = cfg->code_len;
  code = D.31376 + D.31380;
  code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
  code.105 = (int) code;
  D.31376 = cfg->native_code;
  D.31377 = (int) D.31376;
  D.31378 = code.105 - D.31377;
  D.31379 = (unsigned int) D.31378;
  cfg->code_len = D.31379;
  D.31380 = cfg->code_len;
  D.31391 = cfg->code_size;
  D.31392 = D.31380 >= D.31391;
  D.31393 = (long int) D.31392;
  D.31394 = __builtin_expect (D.31393, 0);
  if (D.31394 != 0) goto <D.31395>; else goto <D.31396>;
  <D.31395>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4077, "cfg->code_len < cfg->code_size");
  <D.31396>:
  <D.31390>:
  mono_arch_emit_epilog (cfg);
  <D.31388>:
  bb = bb->next_bb;
  <D.28446>:
  if (bb != 0B) goto <D.28445>; else goto <D.28447>;
  <D.28447>:
  mono_arch_emit_exceptions (cfg);
  max_epilog_size = 0;
  D.31380 = cfg->code_len;
  max_epilog_size.106 = (unsigned int) max_epilog_size;
  D.31398 = D.31380 + max_epilog_size.106;
  cfg->code_size = D.31398;
  D.31368 = cfg->method;
  D.31399 = BIT_FIELD_REF <*D.31368, 8, 168>;
  D.31400 = D.31399 & 2;
  if (D.31400 != 0) goto <D.31401>; else goto <D.31402>;
  <D.31401>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.31403 = monoeg_malloc0 (8);
    cfg->dynamic_info = D.31403;
    D.31404 = cfg->dynamic_info;
    D.31405 = mono_code_manager_new_dynamic ();
    D.31404->code_mp = D.31405;
    {
      int ret;

      D.31406 = cfg->domain;
      D.31407 = &D.31406->lock.mutex;
      ret = pthread_mutex_lock (D.31407);
      if (ret != 0) goto <D.31408>; else goto <D.31409>;
      <D.31408>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.31409>:
      D.31410 = ret != 0;
      D.31411 = (long int) D.31410;
      D.31412 = __builtin_expect (D.31411, 0);
      if (D.31412 != 0) goto <D.31413>; else goto <D.31414>;
      <D.31413>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4106, "ret == 0");
      <D.31414>:
    }
    D.31406 = cfg->domain;
    D.31368 = cfg->method;
    D.31404 = cfg->dynamic_info;
    mono_dynamic_code_hash_insert (D.31406, D.31368, D.31404);
    {
      int ret;

      D.31406 = cfg->domain;
      D.31407 = &D.31406->lock.mutex;
      ret = pthread_mutex_unlock (D.31407);
      if (ret != 0) goto <D.31415>; else goto <D.31416>;
      <D.31415>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.31416>:
      D.31417 = ret != 0;
      D.31418 = (long int) D.31417;
      D.31419 = __builtin_expect (D.31418, 0);
      if (D.31419 != 0) goto <D.31420>; else goto <D.31421>;
      <D.31420>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4108, "ret == 0");
      <D.31421>:
    }
    mono_using_xdebug.104 = mono_using_xdebug;
    if (mono_using_xdebug.104 != 0) goto <D.31422>; else goto <D.31423>;
    <D.31422>:
    D.31391 = cfg->code_size;
    D.31424 = D.31391 + unwindlen;
    D.31425 = (int) D.31424;
    code = mono_domain_code_reserve (code_domain, D.31425);
    goto <D.31426>;
    <D.31423>:
    D.31404 = cfg->dynamic_info;
    D.31427 = D.31404->code_mp;
    D.31391 = cfg->code_size;
    D.31424 = D.31391 + unwindlen;
    D.31425 = (int) D.31424;
    code = mono_code_manager_reserve (D.31427, D.31425);
    <D.31426>:
  }
  goto <D.31428>;
  <D.31402>:
  {
    guint unwindlen;

    unwindlen = 0;
    D.31391 = cfg->code_size;
    D.31429 = D.31391 + unwindlen;
    D.31430 = (int) D.31429;
    code = mono_domain_code_reserve (code_domain, D.31430);
  }
  <D.31428>:
  D.31431 = code == 0B;
  D.31432 = (long int) D.31431;
  D.31433 = __builtin_expect (D.31432, 0);
  if (D.31433 != 0) goto <D.31434>; else goto <D.31435>;
  <D.31434>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4126, "code");
  <D.31435>:
  D.31376 = cfg->native_code;
  D.31380 = cfg->code_len;
  memcpy (code, D.31376, D.31380);
  D.31376 = cfg->native_code;
  monoeg_g_free (D.31376);
  cfg->native_code = code;
  D.31376 = cfg->native_code;
  D.31380 = cfg->code_len;
  code = D.31376 + D.31380;
  mono_postprocess_patches (cfg);
  D.31436 = cfg->verbose_level;
  if (D.31436 != 0) goto <D.31437>; else goto <D.31438>;
  <D.31437>:
  {
    char * nm;

    D.31368 = cfg->method;
    nm = mono_method_full_name (D.31368, 1);
    D.31376 = cfg->native_code;
    D.31376 = cfg->native_code;
    D.31380 = cfg->code_len;
    D.31439 = D.31376 + D.31380;
    D.31380 = cfg->code_len;
    D.31406 = cfg->domain;
    D.31440 = D.31406->friendly_name;
    monoeg_g_print ("Method %s emitted at %p to %p (code length %d) [%s]\n", nm, D.31376, D.31439, D.31380, D.31440);
    monoeg_g_free (nm);
  }
  <D.31438>:
  {
    gboolean is_generic;

    is_generic = 0;
    D.31368 = cfg->method;
    D.31399 = BIT_FIELD_REF <*D.31368, 8, 168>;
    D.31443 = D.31399 & 16;
    if (D.31443 != 0) goto <D.31441>; else goto <D.31444>;
    <D.31444>:
    D.31368 = cfg->method;
    D.31445 = mono_method_get_generic_container (D.31368);
    if (D.31445 != 0B) goto <D.31441>; else goto <D.31446>;
    <D.31446>:
    D.31368 = cfg->method;
    D.31447 = D.31368->klass;
    D.31448 = D.31447->generic_container;
    if (D.31448 != 0B) goto <D.31441>; else goto <D.31449>;
    <D.31449>:
    D.31368 = cfg->method;
    D.31447 = D.31368->klass;
    D.31450 = D.31447->generic_class;
    if (D.31450 != 0B) goto <D.31441>; else goto <D.31442>;
    <D.31441>:
    is_generic = 1;
    <D.31442>:
    D.31451 = cfg->generic_sharing_context;
    if (D.31451 != 0B) goto <D.31452>; else goto <D.31453>;
    <D.31452>:
    D.31454 = is_generic == 0;
    D.31455 = (long int) D.31454;
    D.31456 = __builtin_expect (D.31455, 0);
    if (D.31456 != 0) goto <D.31457>; else goto <D.31458>;
    <D.31457>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4170, "is_generic");
    <D.31458>:
    <D.31453>:
  }
  D.31368 = cfg->method;
  D.31406 = cfg->domain;
  D.31376 = cfg->native_code;
  D.31459 = cfg->patch_info;
  D.31404 = cfg->dynamic_info;
  if (D.31404 != 0B) goto <D.31461>; else goto <D.31462>;
  <D.31461>:
  D.31404 = cfg->dynamic_info;
  iftmp.107 = D.31404->code_mp;
  goto <D.31463>;
  <D.31462>:
  iftmp.107 = 0B;
  <D.31463>:
  D.31464 = cfg->run_cctors;
  D.31465 = (int) D.31464;
  mono_arch_patch_code (D.31368, D.31406, D.31376, D.31459, iftmp.107, D.31465);
  D.31368 = cfg->method;
  D.31399 = BIT_FIELD_REF <*D.31368, 8, 168>;
  D.31400 = D.31399 & 2;
  if (D.31400 != 0) goto <D.31466>; else goto <D.31467>;
  <D.31466>:
  mono_using_xdebug.104 = mono_using_xdebug;
  if (mono_using_xdebug.104 != 0) goto <D.31468>; else goto <D.31469>;
  <D.31468>:
  D.31376 = cfg->native_code;
  D.31391 = cfg->code_size;
  D.31470 = (int) D.31391;
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  mono_domain_code_commit (code_domain, D.31376, D.31470, D.31381);
  goto <D.31471>;
  <D.31469>:
  D.31404 = cfg->dynamic_info;
  D.31427 = D.31404->code_mp;
  D.31376 = cfg->native_code;
  D.31391 = cfg->code_size;
  D.31470 = (int) D.31391;
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  mono_code_manager_commit (D.31427, D.31376, D.31470, D.31381);
  <D.31471>:
  goto <D.31472>;
  <D.31467>:
  D.31376 = cfg->native_code;
  D.31391 = cfg->code_size;
  D.31470 = (int) D.31391;
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  mono_domain_code_commit (code_domain, D.31376, D.31470, D.31381);
  <D.31472>:
  D.31376 = cfg->native_code;
  D.31380 = cfg->code_len;
  D.31381 = (int) D.31380;
  D.31368 = cfg->method;
  mono_profiler_code_buffer_new (D.31376, D.31381, 1, D.31368);
  D.31376 = cfg->native_code;
  D.31380 = cfg->code_len;
  D.31473 = (int) D.31380;
  mono_arch_flush_icache (D.31376, D.31473);
  mono_debug_close_method (cfg);
}


mono_dynamic_code_hash_insert (struct MonoDomain * domain, struct MonoMethod * method, struct MonoJitDynamicMethodInfo * ji)
{
  void * D.31474;
  struct GHashTable * D.31475;
  struct GHashTable * D.31478;

  D.31474 = domain->runtime_info;
  D.31475 = MEM[(struct MonoJitDomainInfo *)D.31474].dynamic_code_hash;
  if (D.31475 == 0B) goto <D.31476>; else goto <D.31477>;
  <D.31476>:
  D.31474 = domain->runtime_info;
  D.31478 = monoeg_g_hash_table_new (0B, 0B);
  MEM[(struct MonoJitDomainInfo *)D.31474].dynamic_code_hash = D.31478;
  <D.31477>:
  D.31474 = domain->runtime_info;
  D.31475 = MEM[(struct MonoJitDomainInfo *)D.31474].dynamic_code_hash;
  monoeg_g_hash_table_insert_replace (D.31475, method, ji, 0);
}


mono_postprocess_patches (struct MonoCompile * cfg)
{
  <unnamed type> D.31479;
  const void * D.31480;
  const char * D.31483;
  char * D.31484;
  char * D.31487;
  struct GHashTable * D.31492;
  <unnamed type> D.31497;
  const void * D.31498;
  struct MonoMethod * D.31499;
  unsigned char D.31500;
  unsigned char D.31501;
  struct MonoJitDynamicMethodInfo * D.31504;
  struct MonoCodeManager * D.31505;
  struct MonoJumpInfoBBTable * D.31506;
  int D.31507;
  unsigned int D.31508;
  unsigned int D.31509;
  int D.31510;
  struct MonoDomain * D.31512;
  struct MonoBasicBlock * * D.31513;
  unsigned int i.108;
  unsigned int D.31515;
  struct MonoBasicBlock * * D.31516;
  struct MonoBasicBlock * D.31517;
  int D.31520;
  _Bool D.31521;
  long int D.31522;
  long int D.31523;
  void * * D.31526;
  void * D.31527;
  unsigned char * D.31529;
  int D.31530;
  sizetype D.31531;
  union mono_mutex_t * D.31532;
  _Bool D.31535;
  long int D.31536;
  long int D.31537;
  void * D.31540;
  struct GHashTable * D.31541;
  struct MonoMethod * D.31542;
  struct GSList * D.31545;
  struct GSList * D.31546;
  _Bool D.31549;
  long int D.31550;
  long int D.31551;
  struct MonoJumpInfo * patch_info;
  int i;

  patch_info = cfg->patch_info;
  goto <D.28370>;
  <D.28369>:
  D.31479 = patch_info->type;
  switch (D.31479) <default: <D.28368>, case 1: <D.28353>, case 4: <D.28362>, case 8: <D.28357>>
  <D.28353>:
  {
    struct MonoJitICallInfo * info;

    D.31480 = patch_info->data.target;
    info = mono_find_jit_icall_by_addr (D.31480);
    if (info != 0B) goto <D.31481>; else goto <D.31482>;
    <D.31481>:
    D.31483 = info->name;
    D.31484 = strstr (D.31483, "ves_array_new_va_");
    if (D.31484 == 0B) goto <D.31485>; else goto <D.31486>;
    <D.31485>:
    D.31483 = info->name;
    D.31487 = strstr (D.31483, "ves_array_element_address_");
    if (D.31487 == 0B) goto <D.31488>; else goto <D.31489>;
    <D.31488>:
    patch_info->type = 7;
    D.31483 = info->name;
    patch_info->data.name = D.31483;
    <D.31489>:
    <D.31486>:
    <D.31482>:
    D.31479 = patch_info->type;
    if (D.31479 == 1) goto <D.31490>; else goto <D.31491>;
    <D.31490>:
    D.31492 = cfg->abs_patches;
    if (D.31492 != 0B) goto <D.31493>; else goto <D.31494>;
    <D.31493>:
    {
      struct MonoJumpInfo * abs_ji;

      D.31492 = cfg->abs_patches;
      D.31480 = patch_info->data.target;
      abs_ji = monoeg_g_hash_table_lookup (D.31492, D.31480);
      if (abs_ji != 0B) goto <D.31495>; else goto <D.31496>;
      <D.31495>:
      D.31497 = abs_ji->type;
      patch_info->type = D.31497;
      D.31498 = abs_ji->data.target;
      patch_info->data.target = D.31498;
      <D.31496>:
    }
    <D.31494>:
    <D.31491>:
    goto <D.28356>;
  }
  <D.28357>:
  {
    void * * table;

    D.31499 = cfg->method;
    D.31500 = BIT_FIELD_REF <*D.31499, 8, 168>;
    D.31501 = D.31500 & 2;
    if (D.31501 != 0) goto <D.31502>; else goto <D.31503>;
    <D.31502>:
    D.31504 = cfg->dynamic_info;
    D.31505 = D.31504->code_mp;
    D.31506 = patch_info->data.table;
    D.31507 = D.31506->table_size;
    D.31508 = (unsigned int) D.31507;
    D.31509 = D.31508 * 4;
    D.31510 = (int) D.31509;
    table = mono_code_manager_reserve (D.31505, D.31510);
    goto <D.31511>;
    <D.31503>:
    D.31512 = cfg->domain;
    D.31506 = patch_info->data.table;
    D.31507 = D.31506->table_size;
    D.31508 = (unsigned int) D.31507;
    D.31509 = D.31508 * 4;
    D.31510 = (int) D.31509;
    table = mono_domain_code_reserve (D.31512, D.31510);
    <D.31511>:
    i = 0;
    goto <D.28360>;
    <D.28359>:
    D.31506 = patch_info->data.table;
    D.31513 = D.31506->table;
    i.108 = (unsigned int) i;
    D.31515 = i.108 * 4;
    D.31516 = D.31513 + D.31515;
    D.31517 = *D.31516;
    if (D.31517 != 0B) goto <D.31518>; else goto <D.31519>;
    <D.31518>:
    D.31506 = patch_info->data.table;
    D.31513 = D.31506->table;
    i.108 = (unsigned int) i;
    D.31515 = i.108 * 4;
    D.31516 = D.31513 + D.31515;
    D.31517 = *D.31516;
    D.31520 = D.31517->native_offset;
    D.31521 = D.31520 == 0;
    D.31522 = (long int) D.31521;
    D.31523 = __builtin_expect (D.31522, 0);
    if (D.31523 != 0) goto <D.31524>; else goto <D.31525>;
    <D.31524>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3815, "patch_info->data.table->table [i]->native_offset");
    <D.31525>:
    i.108 = (unsigned int) i;
    D.31515 = i.108 * 4;
    D.31526 = table + D.31515;
    D.31506 = patch_info->data.table;
    D.31513 = D.31506->table;
    i.108 = (unsigned int) i;
    D.31515 = i.108 * 4;
    D.31516 = D.31513 + D.31515;
    D.31517 = *D.31516;
    D.31520 = D.31517->native_offset;
    D.31527 = (void *) D.31520;
    *D.31526 = D.31527;
    goto <D.31528>;
    <D.31519>:
    i.108 = (unsigned int) i;
    D.31515 = i.108 * 4;
    D.31526 = table + D.31515;
    *D.31526 = 0B;
    <D.31528>:
    i = i + 1;
    <D.28360>:
    D.31506 = patch_info->data.table;
    D.31507 = D.31506->table_size;
    if (D.31507 > i) goto <D.28359>; else goto <D.28361>;
    <D.28361>:
    D.31506 = patch_info->data.table;
    D.31506->table = table;
    goto <D.28356>;
  }
  <D.28362>:
  {
    struct MonoJumpList * jlist;
    struct MonoDomain * domain;
    unsigned char * ip;

    domain = cfg->domain;
    D.31529 = cfg->native_code;
    D.31530 = patch_info->ip.i;
    D.31531 = (sizetype) D.31530;
    ip = D.31529 + D.31531;
    {
      int ret;

      D.31532 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.31532);
      if (ret != 0) goto <D.31533>; else goto <D.31534>;
      <D.31533>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.31534>:
      D.31535 = ret != 0;
      D.31536 = (long int) D.31535;
      D.31537 = __builtin_expect (D.31536, 0);
      if (D.31537 != 0) goto <D.31538>; else goto <D.31539>;
      <D.31538>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3835, "ret == 0");
      <D.31539>:
    }
    D.31540 = domain->runtime_info;
    D.31541 = MEM[(struct MonoJitDomainInfo *)D.31540].jump_target_hash;
    D.31542 = patch_info->data.method;
    jlist = monoeg_g_hash_table_lookup (D.31541, D.31542);
    if (jlist == 0B) goto <D.31543>; else goto <D.31544>;
    <D.31543>:
    jlist = mono_domain_alloc0 (domain, 4);
    D.31540 = domain->runtime_info;
    D.31541 = MEM[(struct MonoJitDomainInfo *)D.31540].jump_target_hash;
    D.31542 = patch_info->data.method;
    monoeg_g_hash_table_insert_replace (D.31541, D.31542, jlist, 0);
    <D.31544>:
    D.31545 = jlist->list;
    D.31546 = monoeg_g_slist_prepend (D.31545, ip);
    jlist->list = D.31546;
    {
      int ret;

      D.31532 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.31532);
      if (ret != 0) goto <D.31547>; else goto <D.31548>;
      <D.31547>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.31548>:
      D.31549 = ret != 0;
      D.31550 = (long int) D.31549;
      D.31551 = __builtin_expect (D.31550, 0);
      if (D.31551 != 0) goto <D.31552>; else goto <D.31553>;
      <D.31552>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3842, "ret == 0");
      <D.31553>:
    }
    goto <D.28356>;
  }
  <D.28368>:
  goto <D.28356>;
  <D.28356>:
  patch_info = patch_info->next;
  <D.28370>:
  if (patch_info != 0B) goto <D.28369>; else goto <D.28371>;
  <D.28371>:
}


mini_get_shared_method_full (struct MonoMethod * method, gboolean all_vt, gboolean is_gsharedvt)
{
  unsigned char D.31558;
  unsigned char D.31559;
  struct MonoClass * D.31561;
  struct MonoGenericContainer * D.31562;
  unsigned char D.31564;
  unsigned char D.31565;
  unsigned char D.31566;
  struct MonoGenericContainer * D.31569;
  struct MonoClass * D.31571;
  struct MonoGenericContainer * D.31572;
  int D.31578;
  int D.31580;
  int iftmp.109;
  int D.31587;
  struct MonoGenericInst * D.31593;
  struct MonoGenericInst * D.31594;
  struct MonoGenericInst * D.31600;
  struct MonoGenericInst * D.31601;
  struct MonoClass * D.31604;
  unsigned char D.31605;
  unsigned char D.31606;
  _Bool D.31607;
  long int D.31608;
  long int D.31609;
  struct MonoMethod * D.31612;
  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.31558 = BIT_FIELD_REF <*method, 8, 168>;
      D.31559 = D.31558 & 8;
      if (D.31559 != 0) goto <D.31555>; else goto <D.31560>;
      <D.31560>:
      D.31561 = method->klass;
      D.31562 = D.31561->generic_container;
      if (D.31562 != 0B) goto <D.31563>; else goto <D.31556>;
      <D.31563>:
      D.31558 = BIT_FIELD_REF <*method, 8, 168>;
      D.31564 = D.31558 & 16;
      if (D.31564 == 0) goto <D.31555>; else goto <D.31556>;
      <D.31555>:
      declaring_method = method;
      goto <D.31557>;
      <D.31556>:
      declaring_method = mono_method_get_declaring_generic_method (method);
      <D.31557>:
      D.31565 = BIT_FIELD_REF <*declaring_method, 8, 168>;
      D.31566 = D.31565 & 8;
      if (D.31566 != 0) goto <D.31567>; else goto <D.31568>;
      <D.31567>:
      D.31569 = mono_method_get_generic_container (declaring_method);
      shared_context = D.31569->context;
      goto <D.31570>;
      <D.31568>:
      D.31571 = declaring_method->klass;
      D.31572 = D.31571->generic_container;
      shared_context = D.31572->context;
      <D.31570>:
      if (method != declaring_method) goto <D.31576>; else goto <D.31573>;
      <D.31576>:
      D.31558 = BIT_FIELD_REF <*method, 8, 168>;
      D.31564 = D.31558 & 16;
      if (D.31564 != 0) goto <D.31577>; else goto <D.31573>;
      <D.31577>:
      D.31578 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.31578 == 0) goto <D.31574>; else goto <D.31573>;
      <D.31573>:
      if (is_gsharedvt != 0) goto <D.31574>; else goto <D.31579>;
      <D.31579>:
      D.31580 = mini_is_gsharedvt_sharable_method (method);
      if (D.31580 != 0) goto <D.31574>; else goto <D.31575>;
      <D.31574>:
      {
        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.31582>; else goto <D.31585>;
        <D.31585>:
        if (partial == 0) goto <D.31586>; else goto <D.31583>;
        <D.31586>:
        D.31587 = mini_is_gsharedvt_sharable_method (method);
        if (D.31587 != 0) goto <D.31582>; else goto <D.31583>;
        <D.31582>:
        iftmp.109 = 1;
        goto <D.31584>;
        <D.31583>:
        iftmp.109 = 0;
        <D.31584>:
        gsharedvt = iftmp.109;
        D.31571 = declaring_method->klass;
        class_container = D.31571->generic_container;
        method_container = mono_method_get_generic_container (declaring_method);
        if (context != 0B) goto <D.31588>; else goto <D.31589>;
        <D.31588>:
        inst = context->class_inst;
        goto <D.31590>;
        <D.31589>:
        inst = shared_context.class_inst;
        <D.31590>:
        if (inst != 0B) goto <D.31591>; else goto <D.31592>;
        <D.31591>:
        D.31593 = shared_context.class_inst;
        D.31594 = get_shared_inst (inst, D.31593, class_container, all_vt, gsharedvt);
        shared_context.class_inst = D.31594;
        <D.31592>:
        if (context != 0B) goto <D.31595>; else goto <D.31596>;
        <D.31595>:
        inst = context->method_inst;
        goto <D.31597>;
        <D.31596>:
        inst = shared_context.method_inst;
        <D.31597>:
        if (inst != 0B) goto <D.31598>; else goto <D.31599>;
        <D.31598>:
        D.31600 = shared_context.method_inst;
        D.31601 = get_shared_inst (inst, D.31600, method_container, all_vt, gsharedvt);
        shared_context.method_inst = D.31601;
        <D.31599>:
        partial = 1;
      }
      <D.31575>:
      res = mono_class_inflate_generic_method (declaring_method, &shared_context);
      if (partial == 0) goto <D.31602>; else goto <D.31603>;
      <D.31602>:
      D.31604 = res->klass;
      D.31605 = BIT_FIELD_REF <*D.31604, 8, 192>;
      D.31606 = D.31605 & 8;
      D.31607 = D.31606 != 0;
      D.31608 = (long int) D.31607;
      D.31609 = __builtin_expect (D.31608, 0);
      if (D.31609 != 0) goto <D.31610>; else goto <D.31611>;
      <D.31610>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4777, "!res->klass->is_inflated");
      <D.31611>:
      <D.31603>:
      D.31612 = res;
      return D.31612;
    }
  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.31615;
  unsigned int D.31616;
  unsigned int D.31617;
  struct MonoType * D.31622;
  int D.31623;
  unsigned char D.31625;
  unsigned int i.110;
  unsigned int D.31628;
  struct MonoType * * D.31629;
  struct MonoType * D.31630;
  struct MonoType * D.31633;
  struct MonoType * D.31637;
  int D.31639;
  struct MonoGenericInst * D.31640;
  struct MonoGenericInst * res;
  struct MonoType * * type_argv;
  int i;

  D.31615 = inst->type_argc;
  D.31616 = (unsigned int) D.31615;
  D.31617 = D.31616 * 4;
  type_argv = monoeg_malloc0 (D.31617);
  i = 0;
  goto <D.28595>;
  <D.28594>:
  if (all_vt == 0) goto <D.31621>; else goto <D.31618>;
  <D.31621>:
  D.31622 = inst->type_argv[i];
  D.31623 = mono_type_is_reference (D.31622);
  if (D.31623 != 0) goto <D.31619>; else goto <D.31624>;
  <D.31624>:
  D.31622 = inst->type_argv[i];
  D.31625 = D.31622->type;
  if (D.31625 == 19) goto <D.31619>; else goto <D.31626>;
  <D.31626>:
  D.31622 = inst->type_argv[i];
  D.31625 = D.31622->type;
  if (D.31625 == 30) goto <D.31619>; else goto <D.31618>;
  <D.31619>:
  i.110 = (unsigned int) i;
  D.31628 = i.110 * 4;
  D.31629 = type_argv + D.31628;
  D.31630 = shared_inst->type_argv[i];
  *D.31629 = D.31630;
  goto <D.31620>;
  <D.31618>:
  if (all_vt != 0) goto <D.31631>; else goto <D.31632>;
  <D.31631>:
  i.110 = (unsigned int) i;
  D.31628 = i.110 * 4;
  D.31629 = type_argv + D.31628;
  D.31630 = shared_inst->type_argv[i];
  D.31633 = get_gsharedvt_type (D.31630);
  *D.31629 = D.31633;
  goto <D.31634>;
  <D.31632>:
  if (gsharedvt != 0) goto <D.31635>; else goto <D.31636>;
  <D.31635>:
  i.110 = (unsigned int) i;
  D.31628 = i.110 * 4;
  D.31629 = type_argv + D.31628;
  D.31630 = shared_inst->type_argv[i];
  D.31637 = get_gsharedvt_type (D.31630);
  *D.31629 = D.31637;
  goto <D.31638>;
  <D.31636>:
  i.110 = (unsigned int) i;
  D.31628 = i.110 * 4;
  D.31629 = type_argv + D.31628;
  D.31622 = inst->type_argv[i];
  *D.31629 = D.31622;
  <D.31638>:
  <D.31634>:
  <D.31620>:
  i = i + 1;
  <D.28595>:
  D.31615 = inst->type_argc;
  D.31639 = (int) D.31615;
  if (D.31639 > i) goto <D.28594>; else goto <D.28596>;
  <D.28596>:
  D.31615 = inst->type_argc;
  D.31639 = (int) D.31615;
  res = mono_metadata_get_generic_inst (D.31639, type_argv);
  monoeg_g_free (type_argv);
  D.31640 = res;
  return D.31640;
}


get_gsharedvt_type (struct MonoType * t)
{
  int iftmp.111;
  struct MonoGenericContainer * D.31646;
  struct MonoGenericParamInfo * D.31648;
  _Bool D.31649;
  long int D.31650;
  long int D.31651;
  struct GHashTable * D.31656;
  struct GHashTable * D.31659;
  struct MonoType * D.31662;
  struct MonoImage * D.31664;
  struct MonoGenericParam * par;
  struct MonoGenericParam * copy;
  struct MonoType * res;
  struct MonoImage * image;

  par = t->data.generic_param;
  image = 0B;
  D.31646 = par->owner;
  if (D.31646 == 0B) goto <D.31643>; else goto <D.31647>;
  <D.31647>:
  D.31648 = &MEM[(struct MonoGenericParamFull *)par].info;
  if (D.31648 == 0B) goto <D.31643>; else goto <D.31644>;
  <D.31643>:
  iftmp.111 = 1;
  goto <D.31645>;
  <D.31644>:
  iftmp.111 = 0;
  <D.31645>:
  D.31649 = iftmp.111 != 0;
  D.31650 = (long int) D.31649;
  D.31651 = __builtin_expect (D.31650, 0);
  if (D.31651 != 0) goto <D.31652>; else goto <D.31653>;
  <D.31652>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4607, "mono_generic_param_info (par)");
  <D.31653>:
  D.31646 = par->owner;
  if (D.31646 != 0B) goto <D.31654>; else goto <D.31655>;
  <D.31654>:
  D.31646 = par->owner;
  image = D.31646->image;
  mono_image_lock (image);
  D.31656 = image->gsharedvt_types;
  if (D.31656 == 0B) goto <D.31657>; else goto <D.31658>;
  <D.31657>:
  D.31659 = monoeg_g_hash_table_new (0B, 0B);
  image->gsharedvt_types = D.31659;
  <D.31658>:
  D.31656 = image->gsharedvt_types;
  res = monoeg_g_hash_table_lookup (D.31656, par);
  mono_image_unlock (image);
  if (res != 0B) goto <D.31660>; else goto <D.31661>;
  <D.31660>:
  D.31662 = res;
  return D.31662;
  <D.31661>:
  copy = mono_image_alloc0 (image, 32);
  memcpy (copy, par, 32);
  goto <D.31663>;
  <D.31655>:
  copy = monoeg_g_memdup (par, 32);
  <D.31663>:
  copy->owner = 0B;
  D.31664 = mono_defaults.corlib;
  copy->image = D.31664;
  copy->serial = 1;
  res = mono_metadata_type_dup (0B, t);
  res->data.generic_param = copy;
  D.31646 = par->owner;
  if (D.31646 != 0B) goto <D.31665>; else goto <D.31666>;
  <D.31665>:
  mono_image_lock (image);
  D.31656 = image->gsharedvt_types;
  monoeg_g_hash_table_insert_replace (D.31656, par, res, 0);
  mono_image_unlock (image);
  <D.31666>:
  D.31662 = res;
  return D.31662;
}


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

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


mini_init_gsctx (struct MonoGenericContext * context, struct MonoGenericSharingContext * gsctx)
{
  struct MonoGenericInst * D.31670;
  <unnamed-unsigned:22> D.31673;
  unsigned int D.31674;
  unsigned int D.31675;
  void * D.31676;
  unsigned char D.31677;
  _Bool D.31678;
  _Bool D.31679;
  _Bool D.31680;
  struct MonoGenericParam * D.31683;
  short unsigned int D.31684;
  gboolean * D.31687;
  unsigned int i.112;
  unsigned int D.31689;
  gboolean * D.31690;
  int D.31691;
  struct MonoGenericInst * D.31692;
  void * D.31695;
  unsigned char D.31696;
  _Bool D.31697;
  _Bool D.31698;
  _Bool D.31699;
  struct MonoGenericParam * D.31702;
  short unsigned int D.31703;
  gboolean * D.31706;
  gboolean * D.31707;
  struct MonoGenericInst * inst;
  int i;

  memset (gsctx, 0, 8);
  D.31670 = context->class_inst;
  if (D.31670 != 0B) goto <D.31671>; else goto <D.31672>;
  <D.31671>:
  inst = context->class_inst;
  D.31673 = inst->type_argc;
  D.31674 = (unsigned int) D.31673;
  D.31675 = D.31674 * 4;
  D.31676 = monoeg_malloc0 (D.31675);
  gsctx->var_is_vt = D.31676;
  i = 0;
  goto <D.28622>;
  <D.28621>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.31677 = type->type;
    D.31678 = D.31677 == 19;
    D.31679 = D.31677 == 30;
    D.31680 = D.31678 | D.31679;
    if (D.31680 != 0) goto <D.31681>; else goto <D.31682>;
    <D.31681>:
    D.31683 = type->data.generic_param;
    D.31684 = D.31683->serial;
    if (D.31684 == 1) goto <D.31685>; else goto <D.31686>;
    <D.31685>:
    D.31687 = gsctx->var_is_vt;
    i.112 = (unsigned int) i;
    D.31689 = i.112 * 4;
    D.31690 = D.31687 + D.31689;
    *D.31690 = 1;
    <D.31686>:
    <D.31682>:
  }
  i = i + 1;
  <D.28622>:
  D.31673 = inst->type_argc;
  D.31691 = (int) D.31673;
  if (D.31691 > i) goto <D.28621>; else goto <D.28623>;
  <D.28623>:
  <D.31672>:
  D.31692 = context->method_inst;
  if (D.31692 != 0B) goto <D.31693>; else goto <D.31694>;
  <D.31693>:
  inst = context->method_inst;
  D.31673 = inst->type_argc;
  D.31674 = (unsigned int) D.31673;
  D.31675 = D.31674 * 4;
  D.31695 = monoeg_malloc0 (D.31675);
  gsctx->mvar_is_vt = D.31695;
  i = 0;
  goto <D.28626>;
  <D.28625>:
  {
    struct MonoType * type;

    type = inst->type_argv[i];
    D.31696 = type->type;
    D.31697 = D.31696 == 19;
    D.31698 = D.31696 == 30;
    D.31699 = D.31697 | D.31698;
    if (D.31699 != 0) goto <D.31700>; else goto <D.31701>;
    <D.31700>:
    D.31702 = type->data.generic_param;
    D.31703 = D.31702->serial;
    if (D.31703 == 1) goto <D.31704>; else goto <D.31705>;
    <D.31704>:
    D.31706 = gsctx->mvar_is_vt;
    i.112 = (unsigned int) i;
    D.31689 = i.112 * 4;
    D.31707 = D.31706 + D.31689;
    *D.31707 = 1;
    <D.31705>:
    <D.31701>:
  }
  i = i + 1;
  <D.28626>:
  D.31673 = inst->type_argc;
  D.31691 = (int) D.31673;
  if (D.31691 > i) goto <D.28625>; else goto <D.28627>;
  <D.28627>:
  <D.31694>:
}


mini_method_compile (struct MonoMethod * method, guint32 opts, struct MonoDomain * domain, JitFlags flags, int parts)
{
  unsigned int D.31708;
  _Bool D.31709;
  unsigned int D.31710;
  _Bool D.31711;
  unsigned int D.31712;
  _Bool D.31713;
  <unnamed type> D.31714;
  unsigned int D.31715;
  int iftmp.113;
  struct MonoClass * D.31726;
  int D.31727;
  unsigned int D.31729;
  unsigned char D.31731;
  unsigned char D.31732;
  struct MonoGenericContainer * D.31734;
  struct MonoGenericClass * D.31736;
  int D.31738;
  int iftmp.114;
  int D.31743;
  int D.31746;
  long unsigned int D.31752;
  long unsigned int D.31753;
  int D.31755;
  long unsigned int D.31758;
  long unsigned int D.31759;
  int D.31760;
  int D.31763;
  int D.31770;
  int D.31773;
  _Bool D.31774;
  long int D.31775;
  long int D.31776;
  _Bool D.31784;
  long int D.31785;
  long int D.31786;
  struct MonoMethod * D.31790;
  struct MonoMethodHeader * D.31791;
  struct MonoMemPool * D.31792;
  <unnamed type> D.31793;
  unsigned char D.31794;
  <unnamed-unsigned:1> D.31795;
  int mini_verbose.115;
  unsigned int mini_verbose.116;
  unsigned char D.31798;
  <unnamed-unsigned:1> D.31799;
  unsigned char D.31800;
  <unnamed-unsigned:1> D.31801;
  <unnamed-unsigned:1> D.31802;
  int D.31803;
  unsigned char D.31804;
  <unnamed-unsigned:1> D.31805;
  int D.31806;
  unsigned char D.31807;
  <unnamed-unsigned:1> D.31808;
  int D.31809;
  unsigned char D.31810;
  <unnamed-unsigned:1> D.31811;
  struct MonoGenericSharingContext * D.31814;
  unsigned char D.31815;
  <unnamed-unsigned:1> D.31816;
  struct GHashTable * D.31817;
  unsigned char D.31818;
  unsigned char D.31819;
  struct GPtrArray * D.31822;
  unsigned char D.31825;
  unsigned char D.31826;
  struct MonoCompile * D.31833;
  struct MonoGenericSharingContext * D.31836;
  int D.31839;
  unsigned char D.31843;
  _Bool D.31844;
  long int D.31845;
  long int D.31846;
  unsigned char D.31852;
  unsigned char D.31853;
  _Bool D.31854;
  long int D.31855;
  long int D.31856;
  _Bool D.31862;
  long int D.31863;
  long int D.31864;
  const char * D.31869;
  gchar * D.31870;
  unsigned char D.31877;
  unsigned int D.31878;
  const char * D.31880;
  gchar * D.31881;
  int D.31884;
  unsigned int D.31887;
  unsigned int D.31888;
  unsigned int D.31889;
  unsigned int D.31890;
  unsigned int D.31891;
  int mono_using_xdebug.117;
  unsigned int D.31897;
  const gchar * D.31898;
  char * D.31904;
  char * D.31906;
  int D.31907;
  int D.28666;
  const gchar * D.31910;
  struct MonoMemPool * D.31913;
  <unnamed-unsigned:15> D.31914;
  unsigned int D.31915;
  unsigned int D.31916;
  void * D.31917;
  unsigned int D.31918;
  const char * iftmp.118;
  int D.31922;
  const char * iftmp.119;
  unsigned int D.31931;
  unsigned int D.31934;
  int count.120;
  int count.121;
  struct MonoExceptionClause * D.31937;
  unsigned char D.31940;
  unsigned char D.31941;
  unsigned char D.31944;
  unsigned char D.31945;
  unsigned int D.31948;
  struct MonoRegState * D.31951;
  unsigned char D.31952;
  unsigned char D.31953;
  struct MonoRegState * D.31956;
  int D.31957;
  unsigned int D.31958;
  unsigned int D.31959;
  int D.31962;
  struct MonoDebugOptions * D.31965;
  int D.31966;
  unsigned int D.31969;
  unsigned int D.31974;
  _Bool D.31981;
  long int D.31982;
  long int D.31983;
  int D.31988;
  unsigned int D.31989;
  unsigned int D.31990;
  unsigned int D.31991;
  int D.31992;
  struct MonoInst * D.31995;
  unsigned char D.31998;
  unsigned char D.31999;
  int D.32000;
  struct MonoInst * D.32001;
  int D.32002;
  int D.32003;
  const unsigned char * D.32004;
  int D.32005;
  struct MonoBasicBlock * D.32006;
  struct MonoInst * D.32007;
  unsigned int D.32011;
  unsigned int D.32012;
  unsigned int D.32015;
  unsigned int D.32018;
  unsigned int D.32021;
  unsigned int D.32024;
  unsigned int D.32031;
  unsigned int D.32033;
  unsigned int D.32034;
  void * D.32035;
  struct MonoBasicBlock * D.32036;
  struct MonoBasicBlock * * D.32037;
  int dfn.122;
  int D.32039;
  unsigned int D.32040;
  unsigned int D.32043;
  unsigned int D.32044;
  unsigned int D.32045;
  unsigned int D.32048;
  int D.32053;
  struct MonoInst * D.32054;
  struct MonoBasicBlock * * D.32055;
  struct MonoBasicBlock * D.32056;
  short int D.32057;
  unsigned int D.32060;
  unsigned int D.32064;
  unsigned int D.32065;
  unsigned int D.32074;
  unsigned int D.32075;
  unsigned char D.32078;
  unsigned int D.32087;
  unsigned int D.32088;
  unsigned int D.32099;
  unsigned int D.32100;
  unsigned int D.32103;
  void * D.32112;
  unsigned int D.32124;
  struct MonoInst * D.32127;
  unsigned char D.32130;
  _Bool D.32131;
  long int D.32132;
  long int D.32133;
  _Bool D.32136;
  long int D.32137;
  long int D.32138;
  void * D.32141;
  unsigned int D.32142;
  signed int D.32143;
  int D.32144;
  long long int D.32145;
  signed int D.32146;
  signed int D.32147;
  unsigned int D.32148;
  unsigned int D.32151;
  unsigned int D.32156;
  unsigned int D.32157;
  void * D.32164;
  unsigned int D.32165;
  unsigned int D.32166;
  regmask_t * D.32169;
  int need_local_opts.123;
  struct MonoInst * D.32184;
  short unsigned int D.32187;
  short unsigned int D.32188;
  _Bool D.32189;
  short unsigned int D.32190;
  _Bool D.32191;
  _Bool D.32192;
  short unsigned int D.32194;
  short unsigned int D.32195;
  struct MonoBasicBlock * * D.32196;
  struct MonoBasicBlock * * D.32197;
  struct MonoBasicBlock * D.32198;
  struct MonoBasicBlock * D.32201;
  short unsigned int D.32208;
  short unsigned int D.32209;
  _Bool D.32210;
  short unsigned int D.32211;
  _Bool D.32212;
  _Bool D.32213;
  short unsigned int D.32215;
  struct MonoInst * D.32217;
  struct MonoInst * D.32219;
  unsigned char D.32220;
  struct MonoBasicBlock * D.32221;
  struct MonoBasicBlock * D.32223;
  unsigned int D.32224;
  unsigned int D.32225;
  short unsigned int D.32226;
  int D.32231;
  unsigned int D.32234;
  struct MonoJitInfo * D.32241;
  unsigned char * D.32246;
  unsigned int D.32247;
  int D.32248;
  char * D.32249;
  struct MonoDomain * D.32252;
  union mono_mutex_t * D.32253;
  _Bool D.32256;
  long int D.32257;
  long int D.32258;
  struct MonoJitInfo * D.32261;
  unsigned char D.32262;
  struct MonoJitDynamicMethodInfo * D.32265;
  _Bool D.32268;
  long int D.32269;
  long int D.32270;
  struct MonoPerfCounters * mono_perfcounters.124;
  unsigned int D.32274;
  unsigned int D.32275;
  unsigned int D.32276;
  unsigned int D.32277;
  int D.32278;
  unsigned int D.32279;
  unsigned int D.32280;
  int D.32281;
  int D.32282;
  int D.32285;
  char * D.32288;
  const char * D.32289;
  const char * D.32290;
  gchar * D.32291;
  int D.32292;
  unsigned int D.32293;
  unsigned int D.32294;
  int D.32295;
  char * D.32300;
  gchar * D.32301;
  int D.32302;
  unsigned int D.32303;
  unsigned int D.32304;
  int D.32305;
  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.31708 = flags & 1;
      D.31709 = D.31708 != 0;
      run_cctors = (gboolean) D.31709;
      D.31710 = flags & 2;
      D.31711 = D.31710 != 0;
      compile_aot = (gboolean) D.31711;
      D.31712 = flags & 4;
      D.31713 = D.31712 != 0;
      full_aot = (gboolean) D.31713;
      InterlockedIncrement (&mono_jit_stats.methods_compiled);
      D.31714 = mono_profiler_get_events ();
      D.31715 = D.31714 & 16;
      if (D.31715 != 0) goto <D.31716>; else goto <D.31717>;
      <D.31716>:
      mono_profiler_method_jit (method);
      <D.31717>:
      if (0 != 0) goto <D.31718>; else goto <D.31719>;
      <D.31718>:
      <D.31719>:
      if (compile_aot != 0) goto <D.31720>; else goto <D.31721>;
      <D.31720>:
      D.31726 = method->klass;
      D.31727 = mono_class_generic_sharing_enabled (D.31726);
      if (D.31727 != 0) goto <D.31728>; else goto <D.31723>;
      <D.31728>:
      D.31729 = opts & 33554432;
      if (D.31729 != 0) goto <D.31730>; else goto <D.31723>;
      <D.31730>:
      D.31731 = BIT_FIELD_REF <*method, 8, 168>;
      D.31732 = D.31731 & 8;
      if (D.31732 != 0) goto <D.31724>; else goto <D.31733>;
      <D.31733>:
      D.31726 = method->klass;
      D.31734 = D.31726->generic_container;
      if (D.31734 != 0B) goto <D.31724>; else goto <D.31735>;
      <D.31735>:
      D.31726 = method->klass;
      D.31736 = D.31726->generic_class;
      if (D.31736 == 0B) goto <D.31737>; else goto <D.31723>;
      <D.31737>:
      D.31738 = mono_method_is_generic_sharable_full (method, 1, 0, 0);
      if (D.31738 != 0) goto <D.31724>; else goto <D.31723>;
      <D.31724>:
      iftmp.113 = 1;
      goto <D.31725>;
      <D.31723>:
      iftmp.113 = 0;
      <D.31725>:
      try_generic_shared = iftmp.113;
      goto <D.31739>;
      <D.31721>:
      D.31726 = method->klass;
      D.31743 = mono_class_generic_sharing_enabled (D.31726);
      if (D.31743 != 0) goto <D.31744>; else goto <D.31741>;
      <D.31744>:
      D.31729 = opts & 33554432;
      if (D.31729 != 0) goto <D.31745>; else goto <D.31741>;
      <D.31745>:
      D.31746 = mono_method_is_generic_sharable (method, 0);
      if (D.31746 != 0) goto <D.31747>; else goto <D.31741>;
      <D.31747>:
      iftmp.114 = 1;
      goto <D.31742>;
      <D.31741>:
      iftmp.114 = 0;
      <D.31742>:
      try_generic_shared = iftmp.114;
      <D.31739>:
      D.31729 = opts & 33554432;
      if (D.31729 != 0) goto <D.31748>; else goto <D.31749>;
      <D.31748>:
      if (try_generic_shared != 0) goto <D.31750>; else goto <D.31751>;
      <D.31750>:
      D.31752 = mono_stats.generics_sharable_methods;
      D.31753 = D.31752 + 1;
      mono_stats.generics_sharable_methods = D.31753;
      goto <D.31754>;
      <D.31751>:
      D.31755 = mono_method_is_generic_impl (method);
      if (D.31755 != 0) goto <D.31756>; else goto <D.31757>;
      <D.31756>:
      D.31758 = mono_stats.generics_unsharable_methods;
      D.31759 = D.31758 + 1;
      mono_stats.generics_unsharable_methods = D.31759;
      <D.31757>:
      <D.31754>:
      <D.31749>:
      D.31760 = mini_is_gsharedvt_sharable_method (method);
      if (D.31760 != 0) goto <D.31761>; else goto <D.31762>;
      <D.31761>:
      D.31763 = mono_debug_count ();
      if (D.31763 == 0) goto <D.31764>; else goto <D.31765>;
      <D.31764>:
      try_generic_shared = 0;
      <D.31765>:
      if (compile_aot != 0) goto <D.31766>; else goto <D.31767>;
      <D.31766>:
      try_generic_shared = 0;
      <D.31767>:
      <D.31762>:
      D.31770 = is_gsharedvt_method (method);
      if (D.31770 != 0) goto <D.31768>; else goto <D.31771>;
      <D.31771>:
      if (compile_aot != 0) goto <D.31772>; else goto <D.31769>;
      <D.31772>:
      D.31773 = is_open_method (method);
      if (D.31773 != 0) goto <D.31768>; else goto <D.31769>;
      <D.31768>:
      method_is_gshared = 1;
      D.31774 = compile_aot == 0;
      D.31775 = (long int) D.31774;
      D.31776 = __builtin_expect (D.31775, 0);
      if (D.31776 != 0) goto <D.31777>; else goto <D.31778>;
      <D.31777>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4884, "compile_aot");
      <D.31778>:
      try_generic_shared = 1;
      <D.31769>:
      restart_compile:
      if (method_is_gshared != 0) goto <D.31779>; else goto <D.31780>;
      <D.31779>:
      method_to_compile = method;
      goto <D.31781>;
      <D.31780>:
      if (try_generic_shared != 0) goto <D.31782>; else goto <D.31783>;
      <D.31782>:
      method_to_compile = mini_get_shared_method (method);
      D.31784 = method_to_compile == 0B;
      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", 4898, "method_to_compile");
      <D.31788>:
      goto <D.31789>;
      <D.31783>:
      method_to_compile = method;
      <D.31789>:
      <D.31781>:
      cfg = monoeg_malloc0 (712);
      cfg->method = method_to_compile;
      D.31790 = cfg->method;
      D.31791 = mono_method_get_header (D.31790);
      cfg->header = D.31791;
      D.31792 = mono_mempool_new ();
      cfg->mempool = D.31792;
      cfg->opt = opts;
      D.31793 = mono_profiler_get_events ();
      cfg->prof_options = D.31793;
      D.31794 = (unsigned char) run_cctors;
      D.31795 = (<unnamed-unsigned:1>) D.31794;
      cfg->run_cctors = D.31795;
      cfg->domain = domain;
      mini_verbose.115 = mini_verbose;
      mini_verbose.116 = (unsigned int) mini_verbose.115;
      cfg->verbose_level = mini_verbose.116;
      D.31798 = (unsigned char) compile_aot;
      D.31799 = (<unnamed-unsigned:1>) D.31798;
      cfg->compile_aot = D.31799;
      D.31800 = (unsigned char) full_aot;
      D.31801 = (<unnamed-unsigned:1>) D.31800;
      cfg->full_aot = D.31801;
      D.31802 = method->skip_visibility;
      cfg->skip_visibility = D.31802;
      cfg->orig_method = method;
      D.31803 = debug_options.gen_seq_points;
      D.31804 = (unsigned char) D.31803;
      D.31805 = (<unnamed-unsigned:1>) D.31804;
      cfg->gen_seq_points = D.31805;
      D.31806 = debug_options.explicit_null_checks;
      D.31807 = (unsigned char) D.31806;
      D.31808 = (<unnamed-unsigned:1>) D.31807;
      cfg->explicit_null_checks = D.31808;
      D.31809 = debug_options.soft_breakpoints;
      D.31810 = (unsigned char) D.31809;
      D.31811 = (<unnamed-unsigned:1>) D.31810;
      cfg->soft_breakpoints = D.31811;
      if (try_generic_shared != 0) goto <D.31812>; else goto <D.31813>;
      <D.31812>:
      D.31814 = &cfg->gsctx;
      cfg->generic_sharing_context = D.31814;
      <D.31813>:
      D.31815 = (unsigned char) try_llvm;
      D.31816 = (<unnamed-unsigned:1>) D.31815;
      cfg->compile_llvm = D.31816;
      D.31817 = monoeg_g_hash_table_new (0B, 0B);
      cfg->token_info_hash = D.31817;
      D.31818 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.31819 = D.31818 & 32;
      if (D.31819 != 0) goto <D.31820>; else goto <D.31821>;
      <D.31820>:
      D.31822 = monoeg_g_ptr_array_new ();
      cfg->seq_points = D.31822;
      <D.31821>:
      D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.31826 = D.31825 & 64;
      if (D.31826 != 0) goto <D.31827>; else goto <D.31828>;
      <D.31827>:
      if (try_generic_shared == 0) goto <D.31829>; else goto <D.31830>;
      <D.31829>:
      D.31731 = BIT_FIELD_REF <*method, 8, 168>;
      D.31732 = D.31731 & 8;
      if (D.31732 != 0) goto <D.31823>; else goto <D.31831>;
      <D.31831>:
      D.31726 = method->klass;
      D.31734 = D.31726->generic_container;
      if (D.31734 != 0B) goto <D.31823>; else goto <D.31832>;
      <D.31832>:
      if (method_is_gshared != 0) goto <D.31823>; else goto <D.31824>;
      <D.31823>:
      cfg->exception_type = 11;
      D.31833 = cfg;
      return D.31833;
      <D.31824>:
      <D.31830>:
      <D.31828>:
      D.31836 = cfg->generic_sharing_context;
      if (D.31836 != 0B) goto <D.31837>; else goto <D.31838>;
      <D.31837>:
      D.31839 = mini_is_gsharedvt_sharable_method (method);
      if (D.31839 != 0) goto <D.31834>; else goto <D.31840>;
      <D.31840>:
      if (method_is_gshared != 0) goto <D.31834>; else goto <D.31835>;
      <D.31834>:
      {
        struct MonoMethodInflated * inflated;
        struct MonoGenericContext * context;

        if (method_is_gshared != 0) goto <D.31841>; else goto <D.31842>;
        <D.31841>:
        D.31731 = BIT_FIELD_REF <*method, 8, 168>;
        D.31843 = D.31731 & 16;
        D.31844 = D.31843 == 0;
        D.31845 = (long int) D.31844;
        D.31846 = __builtin_expect (D.31845, 0);
        if (D.31846 != 0) goto <D.31847>; else goto <D.31848>;
        <D.31847>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4939, "method->is_inflated");
        <D.31848>:
        inflated = method;
        context = &inflated->context;
        D.31774 = compile_aot == 0;
        D.31775 = (long int) D.31774;
        D.31776 = __builtin_expect (D.31775, 0);
        if (D.31776 != 0) goto <D.31849>; else goto <D.31850>;
        <D.31849>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4944, "compile_aot");
        <D.31850>:
        goto <D.31851>;
        <D.31842>:
        D.31852 = BIT_FIELD_REF <*method_to_compile, 8, 168>;
        D.31853 = D.31852 & 16;
        D.31854 = D.31853 == 0;
        D.31855 = (long int) D.31854;
        D.31856 = __builtin_expect (D.31855, 0);
        if (D.31856 != 0) goto <D.31857>; else goto <D.31858>;
        <D.31857>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4946, "method_to_compile->is_inflated");
        <D.31858>:
        inflated = method_to_compile;
        context = &inflated->context;
        <D.31851>:
        D.31814 = &cfg->gsctx;
        mini_init_gsctx (context, D.31814);
        cfg->gsharedvt = 1;
        cfg->disable_llvm = 1;
      }
      <D.31835>:
      <D.31838>:
      D.31836 = cfg->generic_sharing_context;
      if (D.31836 != 0B) goto <D.31859>; else goto <D.31860>;
      <D.31859>:
      method_to_register = method_to_compile;
      goto <D.31861>;
      <D.31860>:
      D.31862 = method != method_to_compile;
      D.31863 = (long int) D.31862;
      D.31864 = __builtin_expect (D.31863, 0);
      if (D.31864 != 0) goto <D.31865>; else goto <D.31866>;
      <D.31865>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4961, "method == method_to_compile");
      <D.31866>:
      method_to_register = method;
      <D.31861>:
      cfg->method_to_register = method_to_register;
      mono_error_init (&err);
      D.31790 = cfg->method;
      sig = mono_method_signature_checked (D.31790, &err);
      if (sig == 0B) goto <D.31867>; else goto <D.31868>;
      <D.31867>:
      cfg->exception_type = 7;
      D.31869 = mono_error_get_message (&err);
      D.31870 = monoeg_strdup (D.31869);
      cfg->exception_message = D.31870;
      mono_error_cleanup (&err);
      if (0 != 0) goto <D.31871>; else goto <D.31872>;
      <D.31871>:
      <D.31872>:
      D.31833 = cfg;
      return D.31833;
      <D.31868>:
      header = cfg->header;
      if (header == 0B) goto <D.31873>; else goto <D.31874>;
      <D.31873>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.31875>; else goto <D.31876>;
        <D.31875>:
        D.31877 = error->exception_type;
        D.31878 = (unsigned int) D.31877;
        cfg->exception_type = D.31878;
        goto <D.31879>;
        <D.31876>:
        cfg->exception_type = 3;
        D.31790 = cfg->method;
        D.31880 = D.31790->name;
        D.31881 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.31880);
        cfg->exception_message = D.31881;
        <D.31879>:
        if (0 != 0) goto <D.31882>; else goto <D.31883>;
        <D.31882>:
        <D.31883>:
        D.31833 = cfg;
        return D.31833;
      }
      <D.31874>:
      D.31884 = debug_options.mdb_optimizations;
      if (D.31884 != 0) goto <D.31885>; else goto <D.31886>;
      <D.31885>:
      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.31887 = cfg->opt;
      D.31888 = D.31887 & 4294967231;
      cfg->opt = D.31888;
      D.31887 = cfg->opt;
      D.31889 = D.31887 & 4294967291;
      cfg->opt = D.31889;
      D.31887 = cfg->opt;
      D.31890 = D.31887 & 4294967263;
      cfg->opt = D.31890;
      D.31887 = cfg->opt;
      D.31891 = D.31887 & 4294967279;
      cfg->opt = D.31891;
      cfg->disable_out_of_line_bblocks = 1;
      <D.31886>:
      mono_using_xdebug.117 = mono_using_xdebug;
      if (mono_using_xdebug.117 != 0) goto <D.31893>; else goto <D.31894>;
      <D.31893>:
      cfg->disable_reuse_registers = 1;
      cfg->disable_reuse_stack_slots = 1;
      cfg->extend_live_ranges = 1;
      cfg->compute_precise_live_ranges = 1;
      <D.31894>:
      mini_gc_init_cfg (cfg);
      if (0 != 0) goto <D.31895>; else goto <D.31896>;
      <D.31895>:
      D.31887 = cfg->opt;
      D.31897 = D.31887 | 262144;
      cfg->opt = D.31897;
      <D.31896>:
      D.31898 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
      if (D.31898 != 0B) goto <D.31899>; else goto <D.31900>;
      <D.31899>:
      {
        const char * name;

        name = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
        D.31904 = __builtin_strchr (name, 46);
        if (D.31904 > name) goto <D.31901>; else goto <D.31905>;
        <D.31905>:
        D.31906 = __builtin_strchr (name, 58);
        if (D.31906 != 0B) goto <D.31901>; else goto <D.31902>;
        <D.31901>:
        {
          struct MonoMethodDesc * desc;

          desc = mono_method_desc_new (name, 1);
          D.31790 = cfg->method;
          D.31907 = mono_method_desc_full_match (desc, D.31790);
          if (D.31907 != 0) goto <D.31908>; else goto <D.31909>;
          <D.31908>:
          cfg->verbose_level = 4;
          <D.31909>:
          mono_method_desc_free (desc);
        }
        goto <D.31903>;
        <D.31902>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.31790 = cfg->method;
          D.31880 = D.31790->name;
          D.31910 = monoeg_g_getenv ("MONO_VERBOSE_METHOD");
          D.28666 = __builtin_strcmp (D.31880, D.31910);
        }
        if (D.28666 == 0) goto <D.31911>; else goto <D.31912>;
        <D.31911>:
        cfg->verbose_level = 4;
        <D.31912>:
        <D.31903>:
      }
      <D.31900>:
      ip = header->code;
      D.31913 = cfg->mempool;
      D.31914 = header->max_stack;
      D.31915 = (unsigned int) D.31914;
      D.31916 = D.31915 * 16;
      D.31917 = mono_mempool_alloc0 (D.31913, D.31916);
      cfg->intvars = D.31917;
      D.31918 = cfg->verbose_level;
      if (D.31918 != 0) goto <D.31919>; else goto <D.31920>;
      <D.31919>:
      {
        char * method_name;

        method_name = mono_method_full_name (method, 1);
        D.31922 = cfg->gsharedvt;
        if (D.31922 != 0) goto <D.31923>; else goto <D.31924>;
        <D.31923>:
        iftmp.118 = "gsharedvt ";
        goto <D.31925>;
        <D.31924>:
        iftmp.118 = "";
        <D.31925>:
        D.31836 = cfg->generic_sharing_context;
        if (D.31836 != 0B) goto <D.31929>; else goto <D.31927>;
        <D.31929>:
        D.31922 = cfg->gsharedvt;
        if (D.31922 == 0) goto <D.31930>; else goto <D.31927>;
        <D.31930>:
        iftmp.119 = "gshared ";
        goto <D.31928>;
        <D.31927>:
        iftmp.119 = "";
        <D.31928>:
        monoeg_g_print ("converting %s%s%smethod %s\n", "", iftmp.118, iftmp.119, method_name);
        monoeg_g_free (method_name);
      }
      <D.31920>:
      D.31887 = cfg->opt;
      D.31931 = D.31887 & 786432;
      if (D.31931 != 0) goto <D.31932>; else goto <D.31933>;
      <D.31932>:
      D.31887 = cfg->opt;
      D.31934 = D.31887 | 2097152;
      cfg->opt = D.31934;
      <D.31933>:
      {
        static int count = 0;

        count.120 = count;
        count.121 = count.120 + 1;
        count = count.121;
      }
      D.31937 = header->clauses;
      if (D.31937 != 0B) goto <D.31938>; else goto <D.31939>;
      <D.31938>:
      cfg->globalra = 0;
      <D.31939>:
      D.31790 = cfg->method;
      D.31940 = BIT_FIELD_REF <*D.31790, 8, 160>;
      D.31941 = D.31940 & 124;
      if (D.31941 == 20) goto <D.31942>; else goto <D.31943>;
      <D.31942>:
      cfg->globalra = 0;
      <D.31943>:
      D.31790 = cfg->method;
      D.31944 = BIT_FIELD_REF <*D.31790, 8, 168>;
      D.31945 = D.31944 & 1;
      if (D.31945 != 0) goto <D.31946>; else goto <D.31947>;
      <D.31946>:
      cfg->globalra = 0;
      <D.31947>:
      D.31948 = header->code_size;
      if (D.31948 > 5000) goto <D.31949>; else goto <D.31950>;
      <D.31949>:
      cfg->globalra = 0;
      <D.31950>:
      D.31951 = mono_regstate_new ();
      cfg->rs = D.31951;
      D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.31953 = D.31952 & 16;
      if (D.31953 != 0) goto <D.31954>; else goto <D.31955>;
      <D.31954>:
      D.31956 = cfg->rs;
      D.31956->next_vreg = 48;
      <D.31955>:
      D.31956 = cfg->rs;
      D.31957 = D.31956->next_vreg;
      D.31958 = (unsigned int) D.31957;
      cfg->next_vreg = D.31958;
      D.31887 = cfg->opt;
      D.31959 = D.31887 & 2097152;
      if (D.31959 != 0) goto <D.31960>; else goto <D.31961>;
      <D.31960>:
      cfg->enable_extended_bblocks = 0;
      <D.31961>:
      D.31790 = cfg->method;
      D.31962 = mono_compile_is_broken (cfg, D.31790, 1);
      if (D.31962 != 0) goto <D.31963>; else goto <D.31964>;
      <D.31963>:
      D.31965 = mini_get_debug_options ();
      D.31966 = D.31965->break_on_unverified;
      if (D.31966 != 0) goto <D.31967>; else goto <D.31968>;
      <D.31967>:
      raise (5);
      <D.31968>:
      D.31833 = cfg;
      return D.31833;
      <D.31964>:
      mono_compile_create_vars (cfg);
      D.31887 = cfg->opt;
      D.31969 = D.31887 & 4294443007;
      cfg->opt = D.31969;
      i = mono_method_to_ir (cfg, method_to_compile, 0B, 0B, 0B, 0B, 0B, 0, 0);
      if (i < 0) goto <D.31970>; else goto <D.31971>;
      <D.31970>:
      if (try_generic_shared != 0) goto <D.31972>; else goto <D.31973>;
      <D.31972>:
      D.31974 = cfg->exception_type;
      if (D.31974 == 11) goto <D.31975>; else goto <D.31976>;
      <D.31975>:
      if (compile_aot != 0) goto <D.31977>; else goto <D.31978>;
      <D.31977>:
      if (0 != 0) goto <D.31979>; else goto <D.31980>;
      <D.31979>:
      <D.31980>:
      D.31833 = cfg;
      return D.31833;
      <D.31978>:
      mono_destroy_compile (cfg);
      try_generic_shared = 0;
      goto restart_compile;
      <D.31976>:
      <D.31973>:
      D.31974 = cfg->exception_type;
      D.31981 = D.31974 == 11;
      D.31982 = (long int) D.31981;
      D.31983 = __builtin_expect (D.31982, 0);
      if (D.31983 != 0) goto <D.31984>; else goto <D.31985>;
      <D.31984>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5206, "cfg->exception_type != MONO_EXCEPTION_GENERIC_SHARING_FAILED");
      <D.31985>:
      if (0 != 0) goto <D.31986>; else goto <D.31987>;
      <D.31986>:
      <D.31987>:
      D.31833 = cfg;
      return D.31833;
      <D.31971>:
      D.31988 = cfg->stat_basic_blocks;
      D.31989 = (unsigned int) D.31988;
      D.31990 = cfg->num_bblocks;
      D.31991 = D.31989 + D.31990;
      D.31992 = (int) D.31991;
      cfg->stat_basic_blocks = D.31992;
      if (0 != 0) goto <D.31993>; else goto <D.31994>;
      <D.31993>:
      {
        struct MonoInst * ins;

        D.31887 = cfg->opt;
        D.31934 = D.31887 | 2097152;
        cfg->opt = D.31934;
        D.31995 = cfg->ret;
        if (D.31995 != 0B) goto <D.31996>; else goto <D.31997>;
        <D.31996>:
        D.31995 = cfg->ret;
        D.31995 = cfg->ret;
        D.31998 = D.31995->flags;
        D.31999 = D.31998 & 251;
        D.31995->flags = D.31999;
        D.31913 = cfg->mempool;
        ins = mono_mempool_alloc (D.31913, 56);
        ins->data.op[1].const_val = 0;
        D.32000 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.32000;
        ins->prev = 0B;
        D.32001 = ins->prev;
        ins->next = D.32001;
        ins->opcode = 335;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.32002 = ins->sreg3;
        ins->sreg2 = D.32002;
        D.32003 = ins->sreg2;
        ins->sreg1 = D.32003;
        D.32004 = cfg->ip;
        ins->cil_code = D.32004;
        D.31995 = cfg->ret;
        D.32005 = D.31995->dreg;
        ins->sreg1 = D.32005;
        D.32006 = cfg->bb_exit;
        D.32007 = D.32006->last_ins;
        if (D.32007 != 0B) goto <D.32008>; else goto <D.32009>;
        <D.32008>:
        D.32006 = cfg->bb_exit;
        D.32007 = D.32006->last_ins;
        D.32007->next = ins;
        D.32006 = cfg->bb_exit;
        D.32007 = D.32006->last_ins;
        ins->prev = D.32007;
        D.32006 = cfg->bb_exit;
        D.32006->last_ins = ins;
        goto <D.32010>;
        <D.32009>:
        D.32006 = cfg->bb_exit;
        D.32006 = cfg->bb_exit;
        D.32006->last_ins = ins;
        D.32007 = D.32006->last_ins;
        D.32006->code = D.32007;
        <D.32010>:
        <D.31997>:
        D.31887 = cfg->opt;
        D.32011 = D.31887 & 4294967167;
        cfg->opt = D.32011;
        D.31887 = cfg->opt;
        D.32012 = D.31887 & 4294967293;
        cfg->opt = D.32012;
      }
      <D.31994>:
      mono_liveness_handle_exception_clauses (cfg);
      mono_handle_out_of_line_bblock (cfg);
      if (1 != 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      mono_decompose_long_opts (cfg);
      <D.32014>:
      D.31887 = cfg->opt;
      D.32015 = D.31887 & 48;
      if (D.32015 != 0) goto <D.32016>; else goto <D.32017>;
      <D.32016>:
      mono_local_cprop (cfg);
      <D.32017>:
      D.31887 = cfg->opt;
      D.32018 = D.31887 & 2;
      if (D.32018 != 0) goto <D.32019>; else goto <D.32020>;
      <D.32019>:
      mono_optimize_branches (cfg);
      <D.32020>:
      mono_handle_global_vregs (cfg);
      D.31887 = cfg->opt;
      D.32021 = D.31887 & 64;
      if (D.32021 != 0) goto <D.32022>; else goto <D.32023>;
      <D.32022>:
      mono_local_deadce (cfg);
      <D.32023>:
      D.31887 = cfg->opt;
      D.32024 = D.31887 & 268435456;
      if (D.32024 != 0) goto <D.32025>; else goto <D.32026>;
      <D.32025>:
      mono_local_alias_analysis (cfg);
      <D.32026>:
      if (1 != 0) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      mono_if_conversion (cfg);
      <D.32028>:
      D.31887 = cfg->opt;
      D.32031 = D.31887 & 524288;
      if (D.32031 != 0) goto <D.32029>; else goto <D.32032>;
      <D.32032>:
      D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.31953 = D.31952 & 16;
      if (D.31953 != 0) goto <D.32029>; else goto <D.32030>;
      <D.32029>:
      mono_remove_critical_edges (cfg);
      <D.32030>:
      D.31913 = cfg->mempool;
      D.31990 = cfg->num_bblocks;
      D.32033 = D.31990 + 1;
      D.32034 = D.32033 * 4;
      D.32035 = mono_mempool_alloc (D.31913, D.32034);
      cfg->bblocks = D.32035;
      D.31990 = cfg->num_bblocks;
      cfg->max_block_num = D.31990;
      dfn = 0;
      D.32036 = cfg->bb_entry;
      D.32037 = cfg->bblocks;
      df_visit (D.32036, &dfn, D.32037);
      D.31990 = cfg->num_bblocks;
      dfn.122 = dfn;
      D.32039 = dfn.122 + 1;
      D.32040 = (unsigned int) D.32039;
      if (D.31990 != D.32040) goto <D.32041>; else goto <D.32042>;
      <D.32041>:
      {
        struct MonoBasicBlock * bb;

        dfn.122 = dfn;
        D.32039 = dfn.122 + 1;
        D.32040 = (unsigned int) D.32039;
        cfg->num_bblocks = D.32040;
        bb = cfg->bb_entry;
        goto <D.28672>;
        <D.28671>:
        D.32043 = bb->flags;
        D.32044 = D.32043 & 4294967294;
        bb->flags = D.32044;
        bb = bb->next_bb;
        <D.28672>:
        if (bb != 0B) goto <D.28671>; else goto <D.28673>;
        <D.28673>:
        D.32036 = cfg->bb_entry;
        compute_reachable (D.32036);
        bb = cfg->bb_entry;
        goto <D.28675>;
        <D.28674>:
        D.32043 = bb->flags;
        D.32045 = D.32043 & 16;
        if (D.32045 != 0) goto <D.32046>; else goto <D.32047>;
        <D.32046>:
        compute_reachable (bb);
        <D.32047>:
        bb = bb->next_bb;
        <D.28675>:
        if (bb != 0B) goto <D.28674>; else goto <D.28676>;
        <D.28676>:
        bb = cfg->bb_entry;
        goto <D.28681>;
        <D.28680>:
        D.32043 = bb->flags;
        D.32048 = D.32043 & 1;
        if (D.32048 == 0) goto <D.32049>; else goto <D.32050>;
        <D.32049>:
        D.31918 = cfg->verbose_level;
        if (D.31918 > 1) goto <D.32051>; else goto <D.32052>;
        <D.32051>:
        D.32053 = bb->block_num;
        monoeg_g_print ("found unreachable code in BB%d\n", D.32053);
        <D.32052>:
        bb->last_ins = 0B;
        D.32054 = bb->last_ins;
        bb->code = D.32054;
        goto <D.28678>;
        <D.28677>:
        D.32055 = bb->out_bb;
        D.32056 = *D.32055;
        mono_unlink_bblock (cfg, bb, D.32056);
        <D.28678>:
        D.32057 = bb->out_count;
        if (D.32057 != 0) goto <D.28677>; else goto <D.28679>;
        <D.28679>:
        <D.32050>:
        bb = bb->next_bb;
        <D.28681>:
        if (bb != 0B) goto <D.28680>; else goto <D.28682>;
        <D.28682>:
        bb = cfg->bb_entry;
        goto <D.28684>;
        <D.28683>:
        D.32043 = bb->flags;
        D.32044 = D.32043 & 4294967294;
        bb->flags = D.32044;
        bb = bb->next_bb;
        <D.28684>:
        if (bb != 0B) goto <D.28683>; else goto <D.28685>;
        <D.28685>:
      }
      <D.32042>:
      D.32060 = cfg->num_varinfo;
      if (D.32060 > 2000) goto <D.32058>; else goto <D.32061>;
      <D.32061>:
      D.31990 = cfg->num_bblocks;
      if (D.31990 > 1000) goto <D.32058>; else goto <D.32059>;
      <D.32058>:
      D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.31826 = D.31825 & 64;
      if (D.31826 == 0) goto <D.32062>; else goto <D.32063>;
      <D.32062>:
      D.31887 = cfg->opt;
      D.32064 = D.31887 & 4294967119;
      cfg->opt = D.32064;
      cfg->disable_ssa = 1;
      <D.32063>:
      <D.32059>:
      D.31887 = cfg->opt;
      D.32065 = D.31887 & 8192;
      if (D.32065 != 0) goto <D.32066>; else goto <D.32067>;
      <D.32066>:
      mono_compile_dominator_info (cfg, 3);
      mono_compute_natural_loops (cfg);
      <D.32067>:
      if (parts == 1) goto <D.32068>; else goto <D.32069>;
      <D.32068>:
      if (0 != 0) goto <D.32070>; else goto <D.32071>;
      <D.32070>:
      <D.32071>:
      D.31833 = cfg;
      return D.31833;
      <D.32069>:
      D.31887 = cfg->opt;
      D.31959 = D.31887 & 2097152;
      if (D.31959 != 0) goto <D.32072>; else goto <D.32073>;
      <D.32072>:
      D.32074 = cfg->comp_done;
      D.32075 = D.32074 & 32;
      if (D.32075 == 0) goto <D.32076>; else goto <D.32077>;
      <D.32076>:
      D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.32078 = D.31825 & 2;
      if (D.32078 == 0) goto <D.32079>; else goto <D.32080>;
      <D.32079>:
      mono_ssa_compute (cfg);
      D.31918 = cfg->verbose_level;
      if (D.31918 > 1) goto <D.32081>; else goto <D.32082>;
      <D.32081>:
      print_dfn (cfg);
      <D.32082>:
      <D.32080>:
      <D.32077>:
      <D.32073>:
      if (parts == 2) goto <D.32083>; else goto <D.32084>;
      <D.32083>:
      if (0 != 0) goto <D.32085>; else goto <D.32086>;
      <D.32085>:
      <D.32086>:
      D.31833 = cfg;
      return D.31833;
      <D.32084>:
      D.32087 = BIT_FIELD_REF <*cfg, 32, 3104>;
      D.32088 = D.32087 & 48;
      if (D.32088 != 0) goto <D.32089>; else goto <D.32090>;
      <D.32089>:
      D.32074 = cfg->comp_done;
      D.32075 = D.32074 & 32;
      if (D.32075 != 0) goto <D.32091>; else goto <D.32092>;
      <D.32091>:
      mono_ssa_cprop (cfg);
      <D.32092>:
      <D.32090>:
      D.32074 = cfg->comp_done;
      D.32075 = D.32074 & 32;
      if (D.32075 != 0) goto <D.32093>; else goto <D.32094>;
      <D.32093>:
      D.31887 = cfg->opt;
      D.32031 = D.31887 & 524288;
      if (D.32031 != 0) goto <D.32095>; else goto <D.32096>;
      <D.32095>:
      mono_perform_ssapre (cfg);
      <D.32096>:
      D.31887 = cfg->opt;
      D.32021 = D.31887 & 64;
      if (D.32021 != 0) goto <D.32097>; else goto <D.32098>;
      <D.32097>:
      mono_ssa_deadce (cfg);
      deadce_has_run = 1;
      <D.32098>:
      D.32099 = cfg->flags;
      D.32100 = D.32099 & 132;
      if (D.32100 != 0) goto <D.32101>; else goto <D.32102>;
      <D.32101>:
      D.31887 = cfg->opt;
      D.32103 = D.31887 & 262144;
      if (D.32103 != 0) goto <D.32104>; else goto <D.32105>;
      <D.32104>:
      mono_perform_abc_removal (cfg);
      <D.32105>:
      <D.32102>:
      mono_ssa_remove (cfg);
      mono_local_cprop (cfg);
      mono_handle_global_vregs (cfg);
      D.31887 = cfg->opt;
      D.32021 = D.31887 & 64;
      if (D.32021 != 0) goto <D.32106>; else goto <D.32107>;
      <D.32106>:
      mono_local_deadce (cfg);
      <D.32107>:
      D.31887 = cfg->opt;
      D.32018 = D.31887 & 2;
      if (D.32018 != 0) goto <D.32108>; else goto <D.32109>;
      <D.32108>:
      {
        struct MonoBasicBlock * bb;

        mono_optimize_branches (cfg);
        D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.31953 = D.31952 & 16;
        if (D.31953 != 0) goto <D.32110>; else goto <D.32111>;
        <D.32110>:
        mono_remove_critical_edges (cfg);
        bb = cfg->bb_entry;
        goto <D.28688>;
        <D.28687>:
        bb->dfn = 0;
        bb = bb->next_bb;
        <D.28688>:
        if (bb != 0B) goto <D.28687>; else goto <D.28689>;
        <D.28689>:
        D.31913 = cfg->mempool;
        D.31990 = cfg->num_bblocks;
        D.32033 = D.31990 + 1;
        D.32034 = D.32033 * 4;
        D.32112 = mono_mempool_alloc (D.31913, D.32034);
        cfg->bblocks = D.32112;
        dfn = 0;
        D.32036 = cfg->bb_entry;
        D.32037 = cfg->bblocks;
        df_visit (D.32036, &dfn, D.32037);
        dfn.122 = dfn;
        D.32039 = dfn.122 + 1;
        D.32040 = (unsigned int) D.32039;
        cfg->num_bblocks = D.32040;
        <D.32111>:
      }
      <D.32109>:
      <D.32094>:
      if (0 != 0) goto <D.32113>; else goto <D.32114>;
      <D.32113>:
      mono_ssa_loop_invariant_code_motion (cfg);
      D.31887 = cfg->opt;
      D.32103 = D.31887 & 262144;
      if (D.32103 != 0) goto <D.32115>; else goto <D.32116>;
      <D.32115>:
      mono_perform_abc_removal (cfg);
      <D.32116>:
      <D.32114>:
      if (parts == 3) goto <D.32117>; else goto <D.32118>;
      <D.32117>:
      if (0 != 0) goto <D.32119>; else goto <D.32120>;
      <D.32119>:
      <D.32120>:
      D.31833 = cfg;
      return D.31833;
      <D.32118>:
      if (0 != 0) goto <D.32121>; else goto <D.32122>;
      <D.32121>:
      mono_decompose_vtype_opts_llvm (cfg);
      goto <D.32123>;
      <D.32122>:
      mono_decompose_vtype_opts (cfg);
      <D.32123>:
      D.32099 = cfg->flags;
      D.32124 = D.32099 & 256;
      if (D.32124 != 0) goto <D.32125>; else goto <D.32126>;
      <D.32125>:
      mono_decompose_array_access_opts (cfg);
      <D.32126>:
      D.32127 = cfg->got_var;
      if (D.32127 != 0B) goto <D.32128>; else goto <D.32129>;
      <D.32128>:
      {
        struct GList * regs;
        int got_reg;

        D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.32130 = D.31952 & 2;
        D.32131 = D.32130 == 0;
        D.32132 = (long int) D.32131;
        D.32133 = __builtin_expect (D.32132, 0);
        if (D.32133 != 0) goto <D.32134>; else goto <D.32135>;
        <D.32134>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5460, "cfg->got_var_allocated");
        <D.32135>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.32136 = regs == 0B;
        D.32137 = (long int) D.32136;
        D.32138 = __builtin_expect (D.32137, 0);
        if (D.32138 != 0) goto <D.32139>; else goto <D.32140>;
        <D.32139>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5473, "regs");
        <D.32140>:
        D.32141 = regs->data;
        got_reg = (int) D.32141;
        monoeg_g_list_free (regs);
        D.32127 = cfg->got_var;
        D.32127->opcode = 366;
        D.32127 = cfg->got_var;
        D.32127->dreg = got_reg;
        D.32142 = cfg->used_int_regs;
        D.32143 = (signed int) D.32142;
        D.32127 = cfg->got_var;
        D.32144 = D.32127->dreg;
        D.32145 = 1 << D.32144;
        D.32146 = (signed int) D.32145;
        D.32147 = D.32143 | D.32146;
        D.32148 = (unsigned int) D.32147;
        cfg->used_int_regs = D.32148;
      }
      <D.32129>:
      mono_liveness_handle_exception_clauses (cfg);
      D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.31953 = D.31952 & 16;
      if (D.31953 != 0) goto <D.32149>; else goto <D.32150>;
      <D.32149>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.28694>;
        <D.28693>:
        mono_arch_lowering_pass (cfg, bb);
        bb = bb->next_bb;
        <D.28694>:
        if (bb != 0B) goto <D.28693>; else goto <D.28695>;
        <D.28695>:
        mono_global_regalloc (cfg);
      }
      <D.32150>:
      D.31887 = cfg->opt;
      D.32151 = D.31887 & 128;
      if (D.32151 != 0) goto <D.32152>; else goto <D.32153>;
      <D.32152>:
      D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.31953 = D.31952 & 16;
      if (D.31953 == 0) goto <D.32154>; else goto <D.32155>;
      <D.32154>:
      {
        struct GList * vars;
        struct GList * regs;
        struct GList * l;

        D.32074 = cfg->comp_done;
        D.32156 = D.32074 & 4294967279;
        cfg->comp_done = D.32156;
        D.32074 = cfg->comp_done;
        D.32157 = D.32074 & 16;
        if (D.32157 == 0) goto <D.32158>; else goto <D.32159>;
        <D.32158>:
        mono_analyze_liveness (cfg);
        <D.32159>:
        vars = mono_arch_get_allocatable_int_vars (cfg);
        if (vars != 0B) goto <D.32160>; else goto <D.32161>;
        <D.32160>:
        regs = mono_arch_get_global_int_regs (cfg);
        D.32127 = cfg->got_var;
        if (D.32127 != 0B) goto <D.32162>; else goto <D.32163>;
        <D.32162>:
        l = regs;
        goto <D.28701>;
        <D.28700>:
        D.32164 = l->data;
        D.32165 = (unsigned int) D.32164;
        D.32127 = cfg->got_var;
        D.32144 = D.32127->dreg;
        D.32166 = (unsigned int) D.32144;
        if (D.32165 == D.32166) goto <D.32167>; else goto <D.32168>;
        <D.32167>:
        regs = monoeg_g_list_delete_link (regs, l);
        goto <D.28699>;
        <D.32168>:
        l = l->next;
        <D.28701>:
        if (l != 0B) goto <D.28700>; else goto <D.28699>;
        <D.28699>:
        <D.32163>:
        D.32169 = &cfg->used_int_regs;
        mono_linear_scan (cfg, vars, regs, D.32169);
        <D.32161>:
      }
      <D.32155>:
      <D.32153>:
      D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.31953 = D.31952 & 16;
      if (D.31953 == 0) goto <D.32170>; else goto <D.32171>;
      <D.32170>:
      mono_arch_allocate_vars (cfg);
      D.31974 = cfg->exception_type;
      if (D.31974 != 0) goto <D.32172>; else goto <D.32173>;
      <D.32172>:
      D.31833 = cfg;
      return D.31833;
      <D.32173>:
      <D.32171>:
      {
        struct MonoBasicBlock * bb;
        gboolean need_local_opts;

        try
          {
            D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.31953 = D.31952 & 16;
            if (D.31953 == 0) goto <D.32174>; else goto <D.32175>;
            <D.32174>:
            mono_spill_global_vars (cfg, &need_local_opts);
            need_local_opts.123 = need_local_opts;
            if (need_local_opts.123 != 0) goto <D.32176>; else goto <D.32179>;
            <D.32179>:
            D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
            D.31826 = D.31825 & 64;
            if (D.31826 != 0) goto <D.32176>; else goto <D.32177>;
            <D.32176>:
            mono_local_cprop (cfg);
            D.31887 = cfg->opt;
            D.32021 = D.31887 & 64;
            if (D.32021 != 0) goto <D.32180>; else goto <D.32181>;
            <D.32180>:
            mono_local_deadce (cfg);
            <D.32181>:
            <D.32177>:
            <D.32175>:
            bb = cfg->bb_entry;
            goto <D.28707>;
            <D.28706>:
            D.32184 = bb->last_ins;
            if (D.32184 != 0B) goto <D.32185>; else goto <D.32186>;
            <D.32185>:
            D.32184 = bb->last_ins;
            D.32187 = D.32184->opcode;
            D.32188 = D.32187 + 64985;
            D.32189 = D.32188 <= 9;
            D.32190 = D.32187 + 64878;
            D.32191 = D.32190 <= 9;
            D.32192 = D.32189 | D.32191;
            if (D.32192 != 0) goto <D.32182>; else goto <D.32193>;
            <D.32193>:
            D.32184 = bb->last_ins;
            D.32194 = D.32184->opcode;
            D.32195 = D.32194 + 64888;
            if (D.32195 <= 9) goto <D.32182>; else goto <D.32183>;
            <D.32182>:
            D.32184 = bb->last_ins;
            D.32196 = D.32184->data.op[1].many_blocks;
            D.32197 = D.32196 + 4;
            D.32198 = *D.32197;
            if (D.32198 != 0B) goto <D.32199>; else goto <D.32200>;
            <D.32199>:
            D.32201 = bb->next_bb;
            D.32184 = bb->last_ins;
            D.32196 = D.32184->data.op[1].many_blocks;
            D.32197 = D.32196 + 4;
            D.32198 = *D.32197;
            if (D.32201 != D.32198) goto <D.32202>; else goto <D.32203>;
            <D.32202>:
            D.32184 = bb->last_ins;
            D.32208 = D.32184->opcode;
            D.32209 = D.32208 + 64985;
            D.32210 = D.32209 <= 9;
            D.32211 = D.32208 + 64878;
            D.32212 = D.32211 <= 9;
            D.32213 = D.32210 | D.32212;
            if (D.32213 != 0) goto <D.32204>; else goto <D.32214>;
            <D.32214>:
            D.32184 = bb->last_ins;
            D.32194 = D.32184->opcode;
            D.32195 = D.32194 + 64888;
            if (D.32195 <= 9) goto <D.32204>; else goto <D.32205>;
            <D.32204>:
            D.32184 = bb->last_ins;
            D.32194 = D.32184->opcode;
            D.32215 = D.32194 + 64878;
            if (D.32215 > 9) goto <D.32216>; else goto <D.32205>;
            <D.32216>:
            D.32184 = bb->last_ins;
            D.32217 = D.32184->data.op[0].src;
            if (D.32217 == 0B) goto <D.32206>; else goto <D.32218>;
            <D.32218>:
            D.32184 = bb->last_ins;
            D.32217 = D.32184->data.op[0].src;
            D.32219 = D.32217->data.op[0].src;
            D.32220 = D.32219->type;
            if (D.32220 != 4) goto <D.32206>; else goto <D.32205>;
            <D.32206>:
            D.32201 = bb->next_bb;
            D.32184 = bb->last_ins;
            D.32196 = D.32184->data.op[1].many_blocks;
            D.32221 = *D.32196;
            if (D.32201 == D.32221) goto <D.32222>; else goto <D.32205>;
            <D.32222>:
            {
              struct MonoBasicBlock * tmp;

              D.32184 = bb->last_ins;
              D.32196 = D.32184->data.op[1].many_blocks;
              tmp = *D.32196;
              D.32184 = bb->last_ins;
              D.32196 = D.32184->data.op[1].many_blocks;
              D.32184 = bb->last_ins;
              D.32196 = D.32184->data.op[1].many_blocks;
              D.32223 = MEM[(struct MonoBasicBlock * *)D.32196 + 4B];
              *D.32196 = D.32223;
              D.32184 = bb->last_ins;
              D.32196 = D.32184->data.op[1].many_blocks;
              D.32197 = D.32196 + 4;
              *D.32197 = tmp;
              D.32184 = bb->last_ins;
              D.32184 = bb->last_ins;
              D.32194 = D.32184->opcode;
              D.32224 = (unsigned int) D.32194;
              D.32225 = mono_reverse_branch_op (D.32224);
              D.32226 = (short unsigned int) D.32225;
              D.32184->opcode = D.32226;
            }
            goto <D.32207>;
            <D.32205>:
            {
              struct MonoInst * inst;

              D.31913 = cfg->mempool;
              inst = mono_mempool_alloc0 (D.31913, 56);
              inst->opcode = 442;
              D.32184 = bb->last_ins;
              D.32196 = D.32184->data.op[1].many_blocks;
              D.32223 = MEM[(struct MonoBasicBlock * *)D.32196 + 4B];
              inst->data.op[0].target_block = D.32223;
              mono_bblock_add_inst (bb, inst);
            }
            <D.32207>:
            <D.32203>:
            <D.32200>:
            <D.32183>:
            <D.32186>:
            bb = bb->next_bb;
            <D.28707>:
            if (bb != 0B) goto <D.28706>; else goto <D.28708>;
            <D.28708>:
            D.31918 = cfg->verbose_level;
            if (D.31918 > 3) goto <D.32227>; else goto <D.32228>;
            <D.32227>:
            D.31952 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.31953 = D.31952 & 16;
            if (D.31953 == 0) goto <D.32229>; else goto <D.32230>;
            <D.32229>:
            bb = cfg->bb_entry;
            goto <D.28715>;
            <D.28714>:
            {
              struct MonoInst * tree;

              tree = bb->code;
              D.32231 = bb->block_num;
              monoeg_g_print ("DUMP BLOCK %d:\n", D.32231);
              if (tree == 0B) goto <D.32232>; else goto <D.32233>;
              <D.32232>:
              // predicted unlikely by continue predictor.
              goto <D.28710>;
              <D.32233>:
              goto <D.28712>;
              <D.28711>:
              mono_print_ins_index (-1, tree);
              tree = tree->next;
              <D.28712>:
              if (tree != 0B) goto <D.28711>; else goto <D.28713>;
              <D.28713>:
            }
            <D.28710>:
            bb = bb->next_bb;
            <D.28715>:
            if (bb != 0B) goto <D.28714>; else goto <D.28716>;
            <D.28716>:
            <D.32230>:
            <D.32228>:
            bb = cfg->bb_entry;
            goto <D.28718>;
            <D.28717>:
            D.32234 = cfg->next_vreg;
            bb->max_vreg = D.32234;
            bb = bb->next_bb;
            <D.28718>:
            if (bb != 0B) goto <D.28717>; else goto <D.28719>;
            <D.28719>:
          }
        finally
          {
            need_local_opts = {CLOBBER};
          }
      }
      if (0 != 0) goto <D.32235>; else goto <D.32236>;
      <D.32235>:
      goto <D.32237>;
      <D.32236>:
      mono_codegen (cfg);
      <D.32237>:
      if (0 != 0) goto <D.32238>; else goto <D.32239>;
      <D.32238>:
      InterlockedIncrement (&mono_jit_stats.methods_with_llvm);
      goto <D.32240>;
      <D.32239>:
      InterlockedIncrement (&mono_jit_stats.methods_without_llvm);
      <D.32240>:
      D.32241 = create_jit_info (cfg, method_to_compile);
      cfg->jit_info = D.32241;
      D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.31826 = D.31825 & 64;
      if (D.31826 == 0) goto <D.32242>; else goto <D.32243>;
      <D.32242>:
      mono_save_xdebug_info (cfg);
      <D.32243>:
      mini_gc_create_gc_map (cfg);
      mono_save_seq_point_info (cfg);
      D.31918 = cfg->verbose_level;
      if (D.31918 > 1) goto <D.32244>; else goto <D.32245>;
      <D.32244>:
      {
        char * id;

        D.31790 = cfg->method;
        id = mono_method_full_name (D.31790, 0);
        D.32246 = cfg->native_code;
        D.32247 = cfg->code_len;
        D.32248 = (int) D.32247;
        D.32249 = id + 3;
        mono_disassemble_code (cfg, D.32246, D.32248, D.32249);
        monoeg_g_free (id);
      }
      <D.32245>:
      D.31825 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.31826 = D.31825 & 64;
      if (D.31826 == 0) goto <D.32250>; else goto <D.32251>;
      <D.32250>:
      {
        int ret;

        D.32252 = cfg->domain;
        D.32253 = &D.32252->lock.mutex;
        ret = pthread_mutex_lock (D.32253);
        if (ret != 0) goto <D.32254>; else goto <D.32255>;
        <D.32254>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.32255>:
        D.32256 = ret != 0;
        D.32257 = (long int) D.32256;
        D.32258 = __builtin_expect (D.32257, 0);
        if (D.32258 != 0) goto <D.32259>; else goto <D.32260>;
        <D.32259>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5653, "ret == 0");
        <D.32260>:
      }
      D.32252 = cfg->domain;
      D.32261 = cfg->jit_info;
      mono_jit_info_table_add (D.32252, D.32261);
      D.31790 = cfg->method;
      D.31944 = BIT_FIELD_REF <*D.31790, 8, 168>;
      D.32262 = D.31944 & 2;
      if (D.32262 != 0) goto <D.32263>; else goto <D.32264>;
      <D.32263>:
      D.32252 = cfg->domain;
      D.31790 = cfg->method;
      D.32265 = mono_dynamic_code_hash_lookup (D.32252, D.31790);
      D.32261 = cfg->jit_info;
      D.32265->ji = D.32261;
      <D.32264>:
      {
        int ret;

        D.32252 = cfg->domain;
        D.32253 = &D.32252->lock.mutex;
        ret = pthread_mutex_unlock (D.32253);
        if (ret != 0) goto <D.32266>; else goto <D.32267>;
        <D.32266>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.32267>:
        D.32268 = ret != 0;
        D.32269 = (long int) D.32268;
        D.32270 = __builtin_expect (D.32269, 0);
        if (D.32270 != 0) goto <D.32271>; else goto <D.32272>;
        <D.32271>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5658, "ret == 0");
        <D.32272>:
      }
      <D.32251>:
      mono_perfcounters.124 = mono_perfcounters;
      D.32274 = mono_perfcounters.124->jit_methods;
      D.32275 = D.32274 + 1;
      mono_perfcounters.124->jit_methods = D.32275;
      mono_perfcounters.124 = mono_perfcounters;
      mono_perfcounters.124 = mono_perfcounters;
      D.32276 = mono_perfcounters.124->jit_bytes;
      D.31948 = header->code_size;
      D.32277 = D.32276 + D.31948;
      mono_perfcounters.124->jit_bytes = D.32277;
      D.32278 = mono_jit_stats.allocated_code_size;
      D.32279 = (unsigned int) D.32278;
      D.32247 = cfg->code_len;
      D.32280 = D.32279 + D.32247;
      D.32281 = (int) D.32280;
      mono_jit_stats.allocated_code_size = D.32281;
      D.32247 = cfg->code_len;
      code_size_ratio = (int) D.32247;
      D.32282 = mono_jit_stats.biggest_method_size;
      if (D.32282 < code_size_ratio) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      D.32285 = mono_jit_stats.enabled;
      if (D.32285 != 0) goto <D.32286>; else goto <D.32287>;
      <D.32286>:
      mono_jit_stats.biggest_method_size = code_size_ratio;
      D.32288 = mono_jit_stats.biggest_method;
      monoeg_g_free (D.32288);
      D.31726 = method->klass;
      D.32289 = D.31726->name;
      D.32290 = method->name;
      D.32291 = monoeg_g_strdup_printf ("%s::%s)", D.32289, D.32290);
      mono_jit_stats.biggest_method = D.32291;
      <D.32287>:
      <D.32284>:
      D.32292 = code_size_ratio * 100;
      D.32293 = (unsigned int) D.32292;
      D.31948 = header->code_size;
      D.32294 = D.32293 / D.31948;
      code_size_ratio = (int) D.32294;
      D.32295 = mono_jit_stats.max_code_size_ratio;
      if (D.32295 < code_size_ratio) goto <D.32296>; else goto <D.32297>;
      <D.32296>:
      D.32285 = mono_jit_stats.enabled;
      if (D.32285 != 0) goto <D.32298>; else goto <D.32299>;
      <D.32298>:
      mono_jit_stats.max_code_size_ratio = code_size_ratio;
      D.32300 = mono_jit_stats.max_ratio_method;
      monoeg_g_free (D.32300);
      D.31726 = method->klass;
      D.32289 = D.31726->name;
      D.32290 = method->name;
      D.32301 = monoeg_g_strdup_printf ("%s::%s)", D.32289, D.32290);
      mono_jit_stats.max_ratio_method = D.32301;
      <D.32299>:
      <D.32297>:
      D.32302 = mono_jit_stats.native_code_size;
      D.32303 = (unsigned int) D.32302;
      D.32247 = cfg->code_len;
      D.32304 = D.32303 + D.32247;
      D.32305 = (int) D.32304;
      mono_jit_stats.native_code_size = D.32305;
      if (0 != 0) goto <D.32306>; else goto <D.32307>;
      <D.32306>:
      <D.32307>:
      D.31833 = cfg;
      return D.31833;
    }
  finally
    {
      err = {CLOBBER};
      dfn = {CLOBBER};
    }
}


is_gsharedvt_method (struct MonoMethod * method)
{
  unsigned char D.32310;
  unsigned char D.32311;
  gboolean D.32314;
  struct MonoType * D.32317;
  int D.32318;
  <unnamed-unsigned:22> D.32321;
  int D.32322;
  int D.32325;
  struct MonoGenericContext * context;
  struct MonoGenericInst * inst;
  int i;

  D.32310 = BIT_FIELD_REF <*method, 8, 168>;
  D.32311 = D.32310 & 16;
  if (D.32311 == 0) goto <D.32312>; else goto <D.32313>;
  <D.32312>:
  D.32314 = 0;
  return D.32314;
  <D.32313>:
  context = mono_method_get_context (method);
  inst = context->class_inst;
  if (inst != 0B) goto <D.32315>; else goto <D.32316>;
  <D.32315>:
  i = 0;
  goto <D.28575>;
  <D.28574>:
  D.32317 = inst->type_argv[i];
  D.32318 = is_gsharedvt_type (D.32317);
  if (D.32318 != 0) goto <D.32319>; else goto <D.32320>;
  <D.32319>:
  D.32314 = 1;
  return D.32314;
  <D.32320>:
  i = i + 1;
  <D.28575>:
  D.32321 = inst->type_argc;
  D.32322 = (int) D.32321;
  if (D.32322 > i) goto <D.28574>; else goto <D.28576>;
  <D.28576>:
  <D.32316>:
  inst = context->method_inst;
  if (inst != 0B) goto <D.32323>; else goto <D.32324>;
  <D.32323>:
  i = 0;
  goto <D.28578>;
  <D.28577>:
  D.32317 = inst->type_argv[i];
  D.32325 = is_gsharedvt_type (D.32317);
  if (D.32325 != 0) goto <D.32326>; else goto <D.32327>;
  <D.32326>:
  D.32314 = 1;
  return D.32314;
  <D.32327>:
  i = i + 1;
  <D.28578>:
  D.32321 = inst->type_argc;
  D.32322 = (int) D.32321;
  if (D.32322 > i) goto <D.28577>; else goto <D.28579>;
  <D.28579>:
  <D.32324>:
  D.32314 = 0;
  return D.32314;
}


is_gsharedvt_type (struct MonoType * t)
{
  gboolean D.32329;
  int iftmp.125;
  unsigned char D.32333;
  _Bool D.32334;
  _Bool D.32335;
  _Bool D.32336;
  struct MonoGenericParam * D.32338;
  short unsigned int D.32339;

  D.32333 = t->type;
  D.32334 = D.32333 == 19;
  D.32335 = D.32333 == 30;
  D.32336 = D.32334 | D.32335;
  if (D.32336 != 0) goto <D.32337>; else goto <D.32331>;
  <D.32337>:
  D.32338 = t->data.generic_param;
  D.32339 = D.32338->serial;
  if (D.32339 == 1) goto <D.32340>; else goto <D.32331>;
  <D.32340>:
  iftmp.125 = 1;
  goto <D.32332>;
  <D.32331>:
  iftmp.125 = 0;
  <D.32332>:
  D.32329 = iftmp.125;
  return D.32329;
}


is_open_method (struct MonoMethod * method)
{
  unsigned char D.32342;
  unsigned char D.32343;
  gboolean D.32346;
  struct MonoGenericInst * D.32347;
  unsigned char D.32350;
  unsigned char D.32351;
  struct MonoGenericInst * D.32354;
  unsigned char D.32357;
  unsigned char D.32358;
  struct MonoGenericContext * context;

  D.32342 = BIT_FIELD_REF <*method, 8, 168>;
  D.32343 = D.32342 & 16;
  if (D.32343 == 0) goto <D.32344>; else goto <D.32345>;
  <D.32344>:
  D.32346 = 0;
  return D.32346;
  <D.32345>:
  context = mono_method_get_context (method);
  D.32347 = context->class_inst;
  if (D.32347 != 0B) goto <D.32348>; else goto <D.32349>;
  <D.32348>:
  D.32347 = context->class_inst;
  D.32350 = BIT_FIELD_REF <*D.32347, 8, 48>;
  D.32351 = D.32350 & 64;
  if (D.32351 != 0) goto <D.32352>; else goto <D.32353>;
  <D.32352>:
  D.32346 = 1;
  return D.32346;
  <D.32353>:
  <D.32349>:
  D.32354 = context->method_inst;
  if (D.32354 != 0B) goto <D.32355>; else goto <D.32356>;
  <D.32355>:
  D.32354 = context->method_inst;
  D.32357 = BIT_FIELD_REF <*D.32354, 8, 48>;
  D.32358 = D.32357 & 64;
  if (D.32358 != 0) goto <D.32359>; else goto <D.32360>;
  <D.32359>:
  D.32346 = 1;
  return D.32346;
  <D.32360>:
  <D.32356>:
  D.32346 = 0;
  return D.32346;
}


mono_compile_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.32362;
  struct MonoType * D.32363;
  int D.32364;
  struct MonoInst * D.32367;
  struct MonoInst * D.32368;
  unsigned char D.32369;
  unsigned char D.32370;
  unsigned int D.32371;
  struct MonoMemPool * D.32374;
  short unsigned int D.32375;
  int D.32376;
  <unnamed-unsigned:1> D.32377;
  int D.32378;
  int D.32379;
  unsigned int D.32380;
  unsigned int D.32381;
  void * D.32382;
  unsigned char D.32383;
  unsigned char D.32384;
  struct MonoInst * * D.32387;
  struct MonoClass * D.32388;
  struct MonoType * D.32389;
  struct MonoInst * D.32390;
  int D.32391;
  unsigned int D.32392;
  unsigned int D.32393;
  struct MonoInst * * D.32394;
  struct MonoType * D.32395;
  struct MonoInst * D.32396;
  struct MonoInst * D.32403;
  struct MonoInst * D.32404;
  unsigned int D.32405;
  short unsigned int D.32406;
  unsigned int D.32407;
  unsigned int D.32408;
  void * D.32409;
  struct MonoInst * * D.32412;
  unsigned int i.126;
  unsigned int D.32414;
  struct MonoInst * * D.32415;
  struct MonoType * D.32416;
  struct MonoInst * D.32417;
  int D.32418;
  unsigned char D.32421;
  unsigned char D.32422;
  unsigned char D.32425;
  unsigned char D.32426;
  struct MonoClass * D.32429;
  struct MonoType * D.32430;
  unsigned char D.32431;
  unsigned char D.32432;
  unsigned char D.32433;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;

  header = cfg->header;
  D.32362 = cfg->method;
  sig = mono_method_signature (D.32362);
  D.32363 = sig->ret;
  D.32364 = mono_type_is_void (D.32363);
  if (D.32364 == 0) goto <D.32365>; else goto <D.32366>;
  <D.32365>:
  D.32363 = sig->ret;
  D.32367 = mono_compile_create_var (cfg, D.32363, 330);
  cfg->ret = D.32367;
  D.32368 = cfg->ret;
  D.32368 = cfg->ret;
  D.32369 = D.32368->flags;
  D.32370 = D.32369 | 4;
  D.32368->flags = D.32370;
  <D.32366>:
  D.32371 = cfg->verbose_level;
  if (D.32371 > 2) goto <D.32372>; else goto <D.32373>;
  <D.32372>:
  monoeg_g_print ("creating vars\n");
  <D.32373>:
  D.32374 = cfg->mempool;
  D.32375 = sig->param_count;
  D.32376 = (int) D.32375;
  D.32377 = sig->hasthis;
  D.32378 = (int) D.32377;
  D.32379 = D.32376 + D.32378;
  D.32380 = (unsigned int) D.32379;
  D.32381 = D.32380 * 4;
  D.32382 = mono_mempool_alloc0 (D.32374, D.32381);
  cfg->args = D.32382;
  D.32383 = BIT_FIELD_REF <*sig, 8, 80>;
  D.32384 = D.32383 & 64;
  if (D.32384 != 0) goto <D.32385>; else goto <D.32386>;
  <D.32385>:
  D.32387 = cfg->args;
  D.32362 = cfg->method;
  D.32388 = D.32362->klass;
  D.32389 = &D.32388->this_arg;
  D.32390 = mono_compile_create_var (cfg, D.32389, 330);
  *D.32387 = D.32390;
  <D.32386>:
  i = 0;
  goto <D.28331>;
  <D.28330>:
  D.32387 = cfg->args;
  D.32377 = sig->hasthis;
  D.32378 = (int) D.32377;
  D.32391 = D.32378 + i;
  D.32392 = (unsigned int) D.32391;
  D.32393 = D.32392 * 4;
  D.32394 = D.32387 + D.32393;
  D.32395 = sig->params[i];
  D.32396 = mono_compile_create_var (cfg, D.32395, 330);
  *D.32394 = D.32396;
  i = i + 1;
  <D.28331>:
  D.32375 = sig->param_count;
  D.32376 = (int) D.32375;
  if (D.32376 > i) goto <D.28330>; else goto <D.28332>;
  <D.28332>:
  D.32371 = cfg->verbose_level;
  if (D.32371 > 2) goto <D.32397>; else goto <D.32398>;
  <D.32397>:
  D.32368 = cfg->ret;
  if (D.32368 != 0B) goto <D.32399>; else goto <D.32400>;
  <D.32399>:
  printf ("\treturn : ");
  D.32368 = cfg->ret;
  mono_print_ins (D.32368);
  <D.32400>:
  D.32383 = BIT_FIELD_REF <*sig, 8, 80>;
  D.32384 = D.32383 & 64;
  if (D.32384 != 0) goto <D.32401>; else goto <D.32402>;
  <D.32401>:
  printf ("\tthis: ");
  D.32387 = cfg->args;
  D.32403 = *D.32387;
  mono_print_ins (D.32403);
  <D.32402>:
  i = 0;
  goto <D.28334>;
  <D.28333>:
  printf ("\targ [%d]: ", i);
  D.32387 = cfg->args;
  D.32377 = sig->hasthis;
  D.32378 = (int) D.32377;
  D.32391 = D.32378 + i;
  D.32392 = (unsigned int) D.32391;
  D.32393 = D.32392 * 4;
  D.32394 = D.32387 + D.32393;
  D.32404 = *D.32394;
  mono_print_ins (D.32404);
  i = i + 1;
  <D.28334>:
  D.32375 = sig->param_count;
  D.32376 = (int) D.32375;
  if (D.32376 > i) goto <D.28333>; else goto <D.28335>;
  <D.28335>:
  <D.32398>:
  D.32405 = cfg->num_varinfo;
  cfg->locals_start = D.32405;
  D.32374 = cfg->mempool;
  D.32406 = header->num_locals;
  D.32407 = (unsigned int) D.32406;
  D.32408 = D.32407 * 4;
  D.32409 = mono_mempool_alloc0 (D.32374, D.32408);
  cfg->locals = D.32409;
  D.32371 = cfg->verbose_level;
  if (D.32371 > 2) goto <D.32410>; else goto <D.32411>;
  <D.32410>:
  monoeg_g_print ("creating locals\n");
  <D.32411>:
  i = 0;
  goto <D.28337>;
  <D.28336>:
  D.32412 = cfg->locals;
  i.126 = (unsigned int) i;
  D.32414 = i.126 * 4;
  D.32415 = D.32412 + D.32414;
  D.32416 = header->locals[i];
  D.32417 = mono_compile_create_var (cfg, D.32416, 329);
  *D.32415 = D.32417;
  i = i + 1;
  <D.28337>:
  D.32406 = header->num_locals;
  D.32418 = (int) D.32406;
  if (D.32418 > i) goto <D.28336>; else goto <D.28338>;
  <D.28338>:
  D.32371 = cfg->verbose_level;
  if (D.32371 > 2) goto <D.32419>; else goto <D.32420>;
  <D.32419>:
  monoeg_g_print ("locals done\n");
  <D.32420>:
  mono_arch_create_vars (cfg);
  D.32362 = cfg->method;
  D.32421 = BIT_FIELD_REF <*D.32362, 8, 168>;
  D.32422 = D.32421 & 1;
  if (D.32422 != 0) goto <D.32423>; else goto <D.32424>;
  <D.32423>:
  D.32425 = BIT_FIELD_REF <*cfg, 8, 3416>;
  D.32426 = D.32425 & 2;
  if (D.32426 != 0) goto <D.32427>; else goto <D.32428>;
  <D.32427>:
  {
    struct MonoInst * lmf_var;

    D.32429 = mono_defaults.int_class;
    D.32430 = &D.32429->byval_arg;
    lmf_var = mono_compile_create_var (cfg, D.32430, 329);
    D.32431 = lmf_var->flags;
    D.32432 = D.32431 | 4;
    lmf_var->flags = D.32432;
    D.32431 = lmf_var->flags;
    D.32433 = D.32431 | 32;
    lmf_var->flags = D.32433;
    cfg->lmf_var = lmf_var;
  }
  <D.32428>:
  <D.32424>:
}


mono_handle_out_of_line_bblock (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * D.32434;
  unsigned char D.32437;
  unsigned char D.32438;
  struct MonoInst * D.32441;
  short unsigned int D.32444;
  short unsigned int D.32445;
  _Bool D.32446;
  short unsigned int D.32447;
  _Bool D.32448;
  _Bool D.32449;
  short unsigned int D.32452;
  short unsigned int D.32453;
  struct MonoMemPool * D.32462;
  int D.32463;
  struct MonoInst * D.32464;
  int D.32465;
  int D.32466;
  const unsigned char * D.32467;
  struct MonoBasicBlock * bb;

  bb = cfg->bb_entry;
  goto <D.28467>;
  <D.28466>:
  D.32434 = bb->next_bb;
  if (D.32434 != 0B) goto <D.32435>; else goto <D.32436>;
  <D.32435>:
  D.32434 = bb->next_bb;
  D.32437 = BIT_FIELD_REF <*D.32434, 8, 912>;
  D.32438 = D.32437 & 1;
  if (D.32438 != 0) goto <D.32439>; else goto <D.32440>;
  <D.32439>:
  D.32441 = bb->last_ins;
  if (D.32441 != 0B) goto <D.32442>; else goto <D.32443>;
  <D.32442>:
  D.32441 = bb->last_ins;
  D.32444 = D.32441->opcode;
  D.32445 = D.32444 + 64985;
  D.32446 = D.32445 > 9;
  D.32447 = D.32444 + 64878;
  D.32448 = D.32447 > 9;
  D.32449 = D.32446 & D.32448;
  if (D.32449 != 0) goto <D.32450>; else goto <D.32451>;
  <D.32450>:
  D.32441 = bb->last_ins;
  D.32452 = D.32441->opcode;
  D.32453 = D.32452 + 64888;
  if (D.32453 > 9) goto <D.32454>; else goto <D.32455>;
  <D.32454>:
  D.32441 = bb->last_ins;
  D.32452 = D.32441->opcode;
  if (D.32452 != 442) goto <D.32456>; else goto <D.32457>;
  <D.32456>:
  D.32441 = bb->last_ins;
  D.32452 = D.32441->opcode;
  if (D.32452 != 759) goto <D.32458>; else goto <D.32459>;
  <D.32458>:
  D.32441 = bb->last_ins;
  D.32452 = D.32441->opcode;
  if (D.32452 != 370) goto <D.32460>; else goto <D.32461>;
  <D.32460>:
  {
    struct MonoInst * ins;

    D.32462 = cfg->mempool;
    ins = mono_mempool_alloc (D.32462, 56);
    ins->data.op[1].const_val = 0;
    D.32463 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.32463;
    ins->prev = 0B;
    D.32464 = ins->prev;
    ins->next = D.32464;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.32465 = ins->sreg3;
    ins->sreg2 = D.32465;
    D.32466 = ins->sreg2;
    ins->sreg1 = D.32466;
    D.32467 = cfg->ip;
    ins->cil_code = D.32467;
    D.32441 = bb->last_ins;
    if (D.32441 != 0B) goto <D.32468>; else goto <D.32469>;
    <D.32468>:
    D.32441 = bb->last_ins;
    D.32441->next = ins;
    D.32441 = bb->last_ins;
    ins->prev = D.32441;
    bb->last_ins = ins;
    goto <D.32470>;
    <D.32469>:
    bb->last_ins = ins;
    D.32441 = bb->last_ins;
    bb->code = D.32441;
    <D.32470>:
    D.32434 = bb->next_bb;
    ins->data.op[0].target_block = D.32434;
  }
  <D.32461>:
  <D.32459>:
  <D.32457>:
  <D.32455>:
  <D.32451>:
  <D.32443>:
  <D.32440>:
  <D.32436>:
  bb = bb->next_bb;
  <D.28467>:
  if (bb != 0B) goto <D.28466>; else goto <D.28468>;
  <D.28468>:
}


compute_reachable (struct MonoBasicBlock * bb)
{
  unsigned int D.32471;
  unsigned int D.32472;
  unsigned int D.32475;
  struct MonoBasicBlock * * D.32476;
  unsigned int i.127;
  unsigned int D.32478;
  struct MonoBasicBlock * * D.32479;
  struct MonoBasicBlock * D.32480;
  short int D.32481;
  int D.32482;
  int i;

  D.32471 = bb->flags;
  D.32472 = D.32471 & 1;
  if (D.32472 == 0) goto <D.32473>; else goto <D.32474>;
  <D.32473>:
  D.32471 = bb->flags;
  D.32475 = D.32471 | 1;
  bb->flags = D.32475;
  i = 0;
  goto <D.28459>;
  <D.28458>:
  D.32476 = bb->out_bb;
  i.127 = (unsigned int) i;
  D.32478 = i.127 * 4;
  D.32479 = D.32476 + D.32478;
  D.32480 = *D.32479;
  compute_reachable (D.32480);
  i = i + 1;
  <D.28459>:
  D.32481 = bb->out_count;
  D.32482 = (int) D.32481;
  if (D.32482 > i) goto <D.28458>; else goto <D.28460>;
  <D.28460>:
  <D.32474>:
}


print_dfn (struct MonoCompile * cfg)
{
  struct MonoMethod * D.32483;
  struct MonoBasicBlock * * D.32484;
  unsigned int i.128;
  unsigned int D.32486;
  struct MonoBasicBlock * * D.32487;
  int D.32488;
  int D.32489;
  struct MonoBasicBlock * * D.32490;
  unsigned int j.129;
  unsigned int D.32492;
  struct MonoBasicBlock * * D.32493;
  struct MonoBasicBlock * D.32494;
  int D.32495;
  short int D.32496;
  int D.32497;
  struct MonoBasicBlock * * D.32498;
  struct MonoBasicBlock * * D.32499;
  struct MonoBasicBlock * D.32500;
  int D.32501;
  short int D.32502;
  int D.32503;
  int iftmp.130;
  struct MonoBasicBlock * D.32505;
  struct MonoBitSet * D.32511;
  int D.32512;
  unsigned int D.32513;
  unsigned int D.32514;
  unsigned int D.32515;
  int D.32516;
  unsigned int D.32517;
  unsigned int D.32518;
  _Bool D.32519;
  long int D.32520;
  long int D.32521;
  guint iftmp.131;
  struct MonoBitSet * D.32530;
  unsigned int i.132;
  unsigned int D.32534;
  int i;
  int j;
  char * code;
  struct MonoBasicBlock * bb;
  struct MonoInst * c;

  {
    char * method_name;

    D.32483 = cfg->method;
    method_name = mono_method_full_name (D.32483, 1);
    monoeg_g_print ("IR code for method %s\n", method_name);
    monoeg_g_free (method_name);
  }
  i = 0;
  goto <D.27928>;
  <D.27927>:
  D.32484 = cfg->bblocks;
  i.128 = (unsigned int) i;
  D.32486 = i.128 * 4;
  D.32487 = D.32484 + D.32486;
  bb = *D.32487;
  code = monoeg_strdup ("\n");
  D.32488 = bb->block_num;
  D.32489 = bb->cil_length;
  monoeg_g_print ("\nBB%d (%d) (len: %d): %s", D.32488, i, D.32489, code);
  c = bb->code;
  goto <D.27919>;
  <D.27918>:
  mono_print_ins_index (-1, c);
  c = c->next;
  <D.27919>:
  if (c != 0B) goto <D.27918>; else goto <D.27920>;
  <D.27920>:
  monoeg_g_print ("\tprev:");
  j = 0;
  goto <D.27922>;
  <D.27921>:
  D.32490 = bb->in_bb;
  j.129 = (unsigned int) j;
  D.32492 = j.129 * 4;
  D.32493 = D.32490 + D.32492;
  D.32494 = *D.32493;
  D.32495 = D.32494->block_num;
  monoeg_g_print (" BB%d", D.32495);
  j = j + 1;
  <D.27922>:
  D.32496 = bb->in_count;
  D.32497 = (int) D.32496;
  if (D.32497 > j) goto <D.27921>; else goto <D.27923>;
  <D.27923>:
  monoeg_g_print ("\t\tsucc:");
  j = 0;
  goto <D.27925>;
  <D.27924>:
  D.32498 = bb->out_bb;
  j.129 = (unsigned int) j;
  D.32492 = j.129 * 4;
  D.32499 = D.32498 + D.32492;
  D.32500 = *D.32499;
  D.32501 = D.32500->block_num;
  monoeg_g_print (" BB%d", D.32501);
  j = j + 1;
  <D.27925>:
  D.32502 = bb->out_count;
  D.32503 = (int) D.32502;
  if (D.32503 > j) goto <D.27924>; else goto <D.27926>;
  <D.27926>:
  D.32505 = bb->idom;
  if (D.32505 != 0B) goto <D.32506>; else goto <D.32507>;
  <D.32506>:
  D.32505 = bb->idom;
  iftmp.130 = D.32505->block_num;
  goto <D.32508>;
  <D.32507>:
  iftmp.130 = -1;
  <D.32508>:
  monoeg_g_print ("\n\tidom: BB%d\n", iftmp.130);
  D.32505 = bb->idom;
  if (D.32505 != 0B) goto <D.32509>; else goto <D.32510>;
  <D.32509>:
  D.32511 = bb->dominators;
  D.32505 = bb->idom;
  D.32512 = D.32505->dfn;
  D.32513 = (unsigned int) D.32512;
  D.32514 = D.32513 / 32;
  D.32515 = D.32511->data[D.32514];
  D.32505 = bb->idom;
  D.32512 = D.32505->dfn;
  D.32516 = D.32512 & 31;
  D.32517 = 1 << D.32516;
  D.32518 = D.32515 & D.32517;
  D.32519 = D.32518 == 0;
  D.32520 = (long int) D.32519;
  D.32521 = __builtin_expect (D.32520, 0);
  if (D.32521 != 0) goto <D.32522>; else goto <D.32523>;
  <D.32522>:
  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.32523>:
  <D.32510>:
  D.32511 = bb->dominators;
  if (D.32511 != 0B) goto <D.32524>; else goto <D.32525>;
  <D.32524>:
  D.32511 = bb->dominators;
  D.32505 = bb->idom;
  if (D.32505 != 0B) goto <D.32527>; else goto <D.32528>;
  <D.32527>:
  D.32505 = bb->idom;
  D.32512 = D.32505->dfn;
  iftmp.131 = (guint) D.32512;
  goto <D.32529>;
  <D.32528>:
  iftmp.131 = 4294967295;
  <D.32529>:
  mono_blockset_print (cfg, D.32511, "\tdominators", iftmp.131);
  <D.32525>:
  D.32530 = bb->dfrontier;
  if (D.32530 != 0B) goto <D.32531>; else goto <D.32532>;
  <D.32531>:
  D.32530 = bb->dfrontier;
  mono_blockset_print (cfg, D.32530, "\tdfrontier", 4294967295);
  <D.32532>:
  monoeg_g_free (code);
  i = i + 1;
  <D.27928>:
  i.132 = (unsigned int) i;
  D.32534 = cfg->num_bblocks;
  if (i.132 < D.32534) goto <D.27927>; else goto <D.27929>;
  <D.27929>:
  monoeg_g_print ("\n");
}


df_visit (struct MonoBasicBlock * start, int * dfn, struct MonoBasicBlock * * array)
{
  int D.32535;
  unsigned int D.32536;
  unsigned int D.32537;
  struct MonoBasicBlock * * D.32538;
  struct MonoBasicBlock * * D.32539;
  unsigned int i.133;
  unsigned int D.32541;
  struct MonoBasicBlock * * D.32542;
  struct MonoBasicBlock * D.32543;
  int D.32544;
  int D.32547;
  short int D.32548;
  int D.32549;
  int i;

  D.32535 = *dfn;
  D.32536 = (unsigned int) D.32535;
  D.32537 = D.32536 * 4;
  D.32538 = array + D.32537;
  *D.32538 = start;
  i = 0;
  goto <D.27422>;
  <D.27421>:
  D.32539 = start->out_bb;
  i.133 = (unsigned int) i;
  D.32541 = i.133 * 4;
  D.32542 = D.32539 + D.32541;
  D.32543 = *D.32542;
  D.32544 = D.32543->dfn;
  if (D.32544 != 0) goto <D.32545>; else goto <D.32546>;
  <D.32545>:
  // predicted unlikely by continue predictor.
  goto <D.27420>;
  <D.32546>:
  D.32535 = *dfn;
  D.32547 = D.32535 + 1;
  *dfn = D.32547;
  D.32539 = start->out_bb;
  i.133 = (unsigned int) i;
  D.32541 = i.133 * 4;
  D.32542 = D.32539 + D.32541;
  D.32543 = *D.32542;
  D.32535 = *dfn;
  D.32543->dfn = D.32535;
  D.32539 = start->out_bb;
  i.133 = (unsigned int) i;
  D.32541 = i.133 * 4;
  D.32542 = D.32539 + D.32541;
  D.32543 = *D.32542;
  D.32543->df_parent = start;
  D.32535 = *dfn;
  D.32536 = (unsigned int) D.32535;
  D.32537 = D.32536 * 4;
  D.32538 = array + D.32537;
  D.32539 = start->out_bb;
  i.133 = (unsigned int) i;
  D.32541 = i.133 * 4;
  D.32542 = D.32539 + D.32541;
  D.32543 = *D.32542;
  *D.32538 = D.32543;
  D.32539 = start->out_bb;
  i.133 = (unsigned int) i;
  D.32541 = i.133 * 4;
  D.32542 = D.32539 + D.32541;
  D.32543 = *D.32542;
  df_visit (D.32543, dfn, array);
  <D.27420>:
  i = i + 1;
  <D.27422>:
  D.32548 = start->out_count;
  D.32549 = (int) D.32548;
  if (D.32549 > i) goto <D.27421>; else goto <D.27423>;
  <D.27423>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.32550;
  unsigned int D.32551;

  D.32551 = __sync_add_and_fetch_4 (val, 1);
  D.32550 = (gint32) D.32551;
  return D.32550;
}


create_jit_info (struct MonoCompile * cfg, struct MonoMethod * method_to_compile)
{
  struct MonoMethod * D.32553;
  _Bool D.32554;
  long int D.32555;
  long int D.32556;
  struct MonoGenericSharingContext * D.32559;
  unsigned char D.32563;
  unsigned char D.32564;
  struct MonoMethod * D.32567;
  short unsigned int D.32568;
  int D.32569;
  int D.32570;
  unsigned int D.32571;
  unsigned int D.32572;
  int D.32573;
  struct GSList * D.32576;
  struct MonoBasicBlock * D.32579;
  int D.32580;
  int D.32581;
  struct MonoBasicBlock * * D.32582;
  unsigned int D.32583;
  unsigned int D.32584;
  unsigned int D.32585;
  unsigned int D.32586;
  struct MonoBasicBlock * * D.32587;
  _Bool D.32588;
  long int D.32589;
  long int D.32590;
  int D.32593;
  unsigned int num_holes.134;
  unsigned int D.32599;
  unsigned int D.32600;
  unsigned int D.32601;
  _Bool D.32602;
  long int D.32603;
  long int D.32604;
  unsigned char D.32607;
  unsigned int D.32612;
  <unnamed-unsigned:15> D.32614;
  unsigned char D.32615;
  unsigned char D.32616;
  unsigned int num_clauses.135;
  unsigned int D.32620;
  unsigned int generic_info_size.136;
  unsigned int D.32622;
  unsigned int holes_size.137;
  unsigned int D.32624;
  unsigned int arch_eh_info_size.138;
  unsigned int D.32626;
  unsigned int cas_size.139;
  unsigned int D.32628;
  unsigned int D.32629;
  struct MonoDomain * D.32631;
  unsigned char * D.32632;
  unsigned int D.32633;
  int D.32634;
  unsigned int D.32635;
  unsigned int D.32636;
  unsigned int D.32637;
  _Bool D.32638;
  <unnamed-signed:1> D.32639;
  short unsigned int D.32640;
  <unnamed-unsigned:15> D.32641;
  _Bool D.32646;
  long int D.32647;
  long int D.32648;
  void * D.32653;
  void * D.32655;
  struct MonoGenericSharingContext * D.32656;
  short unsigned int D.32659;
  int D.32660;
  int D.32661;
  struct MonoGenericContext * D.32663;
  struct MonoGenericInst * D.32664;
  struct MonoClass * D.32666;
  unsigned char D.32667;
  unsigned char D.32668;
  struct MonoInst * D.32669;
  _Bool D.32670;
  long int D.32671;
  long int D.32672;
  struct MonoGenericContext * D.32679;
  struct MonoGenericInst * D.32680;
  short unsigned int D.32684;
  _Bool D.32685;
  long int D.32686;
  long int D.32687;
  struct MonoInst * * D.32690;
  unsigned int D.32693;
  int D.32694;
  int D.32697;
  unsigned int D.32698;
  unsigned int D.32699;
  void * D.32700;
  void * D.32702;
  struct MonoDwarfLocListEntry * D.32703;
  unsigned int i.140;
  unsigned int D.32705;
  struct MonoDwarfLocListEntry * D.32706;
  void * D.32707;
  int D.32710;
  _Bool D.32711;
  long int D.32712;
  long int D.32713;
  unsigned char D.32716;
  int D.32717;
  int D.32721;
  unsigned char D.32722;
  int D.32728;
  unsigned char D.32729;
  int D.32730;
  short unsigned int D.32733;
  struct MonoBasicBlock * D.32734;
  int D.32735;
  int D.32736;
  unsigned int D.32737;
  unsigned int D.32738;
  unsigned int D.32739;
  unsigned int D.32740;
  struct MonoBasicBlock * * D.32741;
  _Bool D.32742;
  long int D.32743;
  long int D.32744;
  int D.32747;
  int D.32750;
  int D.32751;
  int i.141;
  struct MonoExceptionClause * D.32753;
  int D.32754;
  struct MonoExceptionClause * D.32755;
  int D.32756;
  int D.32757;
  int D.32758;
  short unsigned int D.32759;
  unsigned int D.32760;
  short unsigned int D.32761;
  short unsigned int D.32762;
  short unsigned int D.32763;
  short unsigned int D.32766;
  int D.32767;
  unsigned int D.32768;
  short unsigned int D.32769;
  int D.32770;
  _Bool D.32771;
  long int D.32772;
  long int D.32773;
  struct MonoJitExceptionInfo * D.32784;
  struct MonoJitExceptionInfo * D.32785;
  short unsigned int D.32787;
  short unsigned int D.32788;
  unsigned int i.142;
  unsigned int D.32792;
  unsigned int D.32793;
  unsigned int D.32794;
  int D.32795;
  int iftmp.143;
  unsigned int D.32800;
  unsigned int D.32803;
  unsigned int D.32804;
  struct MonoBasicBlock * * D.32805;
  _Bool D.32806;
  long int D.32807;
  long int D.32808;
  int D.32811;
  sizetype D.32812;
  void * D.32813;
  struct MonoClass * D.32815;
  unsigned int D.32816;
  unsigned int D.32817;
  struct MonoBasicBlock * * D.32818;
  _Bool D.32821;
  long int D.32822;
  long int D.32823;
  unsigned char D.32826;
  unsigned char D.32827;
  void * D.32830;
  void * D.32831;
  unsigned int D.32832;
  unsigned int D.32833;
  unsigned int D.32834;
  struct MonoBasicBlock * * D.32835;
  unsigned int j.144;
  unsigned int D.32841;
  struct MonoBasicBlock * * D.32842;
  int D.32845;
  unsigned int D.32850;
  struct MonoBasicBlock * * D.32851;
  struct MonoBasicBlock * D.32854;
  int D.32855;
  int D.32856;
  int D.32857;
  sizetype D.32858;
  struct MonoExceptionClause * D.32859;
  void * D.32862;
  int D.32867;
  int D.32868;
  int D.32869;
  int D.32870;
  sizetype D.32871;
  void * D.32872;
  unsigned int D.32875;
  unsigned int D.32876;
  unsigned int D.32877;
  unsigned int D.32880;
  struct MonoBasicBlock * * D.32881;
  unsigned int j.145;
  unsigned int D.32886;
  struct MonoBasicBlock * * D.32887;
  int D.32890;
  int D.32893;
  unsigned int D.32895;
  sizetype end_offset.146;
  void * D.32897;
  int D.32898;
  void * D.32901;
  int D.32902;
  void * D.32903;
  int D.32904;
  void * D.32905;
  int D.32906;
  void * D.32907;
  int D.32908;
  unsigned int D.32909;
  <unnamed-unsigned:15> D.32910;
  int D.32911;
  guint8 * D.32912;
  unsigned int D.32915;
  unsigned int D.32916;
  struct GSList * D.32918;
  unsigned int info_len.147;
  unsigned int D.32922;
  struct MonoJitInfo * D.32923;
  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.32553 = cfg->method;
  D.32554 = D.32553 != method_to_compile;
  D.32555 = (long int) D.32554;
  D.32556 = __builtin_expect (D.32555, 0);
  if (D.32556 != 0) goto <D.32557>; else goto <D.32558>;
  <D.32557>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4280, "method_to_compile == cfg->method");
  <D.32558>:
  header = cfg->header;
  D.32559 = cfg->generic_sharing_context;
  if (D.32559 != 0B) goto <D.32560>; else goto <D.32561>;
  <D.32560>:
  generic_info_size = 20;
  goto <D.32562>;
  <D.32561>:
  generic_info_size = 0;
  <D.32562>:
  D.32563 = BIT_FIELD_REF <*cfg, 8, 3432>;
  D.32564 = D.32563 & 2;
  if (D.32564 != 0) goto <D.32565>; else goto <D.32566>;
  <D.32565>:
  {
    struct MonoJitArgumentInfo * arg_info;
    struct MonoMethodSignature * sig;

    D.32567 = cfg->method_to_register;
    sig = mono_method_signature (D.32567);
    D.32568 = sig->param_count;
    D.32569 = (int) D.32568;
    D.32570 = D.32569 + 1;
    D.32571 = (unsigned int) D.32570;
    D.32572 = D.32571 * 6;
    arg_info = __builtin_alloca (D.32572);
    D.32559 = cfg->generic_sharing_context;
    D.32568 = sig->param_count;
    D.32569 = (int) D.32568;
    D.32573 = mono_arch_get_argument_info (D.32559, sig, D.32569, arg_info);
    stack_size = (guint32) D.32573;
    if (stack_size != 0) goto <D.32574>; else goto <D.32575>;
    <D.32574>:
    arch_eh_info_size = 4;
    <D.32575>:
  }
  <D.32566>:
  D.32576 = cfg->try_block_holes;
  if (D.32576 != 0B) goto <D.32577>; else goto <D.32578>;
  <D.32577>:
  tmp = cfg->try_block_holes;
  goto <D.28498>;
  <D.28497>:
  {
    struct TryBlockHole * hole;
    struct MonoExceptionClause * ec;
    int hole_end;
    struct MonoBasicBlock * clause_last_bb;

    hole = tmp->data;
    ec = hole->clause;
    D.32579 = hole->basic_block;
    D.32580 = D.32579->native_offset;
    D.32579 = hole->basic_block;
    D.32581 = D.32579->native_length;
    hole_end = D.32580 + D.32581;
    D.32582 = cfg->cil_offset_to_bb;
    D.32583 = ec->try_offset;
    D.32584 = ec->try_len;
    D.32585 = D.32583 + D.32584;
    D.32586 = D.32585 * 4;
    D.32587 = D.32582 + D.32586;
    clause_last_bb = *D.32587;
    D.32588 = clause_last_bb == 0B;
    D.32589 = (long int) D.32588;
    D.32590 = __builtin_expect (D.32589, 0);
    if (D.32590 != 0) goto <D.32591>; else goto <D.32592>;
    <D.32591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4309, "clause_last_bb");
    <D.32592>:
    D.32593 = clause_last_bb->native_offset;
    if (D.32593 != hole_end) goto <D.32594>; else goto <D.32595>;
    <D.32594>:
    num_holes = num_holes + 1;
    <D.32595>:
  }
  tmp = tmp->next;
  <D.28498>:
  if (tmp != 0B) goto <D.28497>; else goto <D.28499>;
  <D.28499>:
  if (num_holes != 0) goto <D.32596>; else goto <D.32597>;
  <D.32596>:
  num_holes.134 = (unsigned int) num_holes;
  D.32599 = num_holes.134 * 8;
  D.32600 = D.32599 + 4;
  holes_size = (int) D.32600;
  <D.32597>:
  D.32601 = cfg->verbose_level;
  D.32602 = D.32601 > 3;
  D.32603 = (long int) D.32602;
  D.32604 = __builtin_expect (D.32603, 0);
  if (D.32604 != 0) goto <D.32605>; else goto <D.32606>;
  <D.32605>:
  printf ("Number of try block holes %d\n", num_holes);
  <D.32606>:
  <D.32578>:
  D.32567 = cfg->method_to_register;
  D.32607 = mono_method_has_declsec (D.32567);
  if (D.32607 != 0) goto <D.32608>; else goto <D.32609>;
  <D.32608>:
  cas_size = 4;
  <D.32609>:
  if (0 != 0) goto <D.32610>; else goto <D.32611>;
  <D.32610>:
  D.32612 = cfg->llvm_ex_info_len;
  num_clauses = (int) D.32612;
  goto <D.32613>;
  <D.32611>:
  D.32614 = header->num_clauses;
  num_clauses = (int) D.32614;
  <D.32613>:
  D.32553 = cfg->method;
  D.32615 = BIT_FIELD_REF <*D.32553, 8, 168>;
  D.32616 = D.32615 & 2;
  if (D.32616 != 0) goto <D.32617>; else goto <D.32618>;
  <D.32617>:
  num_clauses.135 = (unsigned int) num_clauses;
  D.32620 = num_clauses.135 * 24;
  generic_info_size.136 = (unsigned int) generic_info_size;
  D.32622 = D.32620 + generic_info_size.136;
  holes_size.137 = (unsigned int) holes_size;
  D.32624 = D.32622 + holes_size.137;
  arch_eh_info_size.138 = (unsigned int) arch_eh_info_size;
  D.32626 = D.32624 + arch_eh_info_size.138;
  cas_size.139 = (unsigned int) cas_size;
  D.32628 = D.32626 + cas_size.139;
  D.32629 = D.32628 + 28;
  jinfo = monoeg_malloc0 (D.32629);
  goto <D.32630>;
  <D.32618>:
  D.32631 = cfg->domain;
  num_clauses.135 = (unsigned int) num_clauses;
  D.32620 = num_clauses.135 * 24;
  generic_info_size.136 = (unsigned int) generic_info_size;
  D.32622 = D.32620 + generic_info_size.136;
  holes_size.137 = (unsigned int) holes_size;
  D.32624 = D.32622 + holes_size.137;
  arch_eh_info_size.138 = (unsigned int) arch_eh_info_size;
  D.32626 = D.32624 + arch_eh_info_size.138;
  cas_size.139 = (unsigned int) cas_size;
  D.32628 = D.32626 + cas_size.139;
  D.32629 = D.32628 + 28;
  jinfo = mono_domain_alloc0 (D.32631, D.32629);
  <D.32630>:
  D.32567 = cfg->method_to_register;
  jinfo->d.method = D.32567;
  D.32632 = cfg->native_code;
  jinfo->code_start = D.32632;
  D.32633 = cfg->code_len;
  D.32634 = (int) D.32633;
  jinfo->code_size = D.32634;
  D.32635 = cfg->used_int_regs;
  jinfo->used_regs = D.32635;
  D.32636 = cfg->opt;
  D.32637 = D.32636 & 512;
  D.32638 = D.32637 != 0;
  D.32639 = (<unnamed-signed:1>) D.32638;
  jinfo->domain_neutral = D.32639;
  D.32640 = (short unsigned int) num_clauses;
  D.32641 = (<unnamed-unsigned:15>) D.32640;
  jinfo->num_clauses = D.32641;
  if (0 != 0) goto <D.32642>; else goto <D.32643>;
  <D.32642>:
  jinfo->from_llvm = -1;
  <D.32643>:
  D.32559 = cfg->generic_sharing_context;
  if (D.32559 != 0B) goto <D.32644>; else goto <D.32645>;
  <D.32644>:
  {
    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.32646 = gi == 0B;
    D.32647 = (long int) D.32646;
    D.32648 = __builtin_expect (D.32647, 0);
    if (D.32648 != 0) goto <D.32649>; else goto <D.32650>;
    <D.32649>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4357, "gi");
    <D.32650>:
    D.32553 = cfg->method;
    D.32615 = BIT_FIELD_REF <*D.32553, 8, 168>;
    D.32616 = D.32615 & 2;
    if (D.32616 != 0) goto <D.32651>; else goto <D.32652>;
    <D.32651>:
    D.32653 = monoeg_malloc0 (8);
    gi->generic_sharing_context = D.32653;
    goto <D.32654>;
    <D.32652>:
    D.32631 = cfg->domain;
    D.32655 = mono_domain_alloc0 (D.32631, 8);
    gi->generic_sharing_context = D.32655;
    <D.32654>:
    D.32656 = gi->generic_sharing_context;
    D.32559 = cfg->generic_sharing_context;
    memcpy (D.32656, D.32559, 8);
    D.32659 = method_to_compile->flags;
    D.32660 = (int) D.32659;
    D.32661 = D.32660 & 16;
    if (D.32661 != 0) goto <D.32657>; else goto <D.32662>;
    <D.32662>:
    D.32663 = mini_method_get_context (method_to_compile);
    D.32664 = D.32663->method_inst;
    if (D.32664 != 0B) goto <D.32657>; else goto <D.32665>;
    <D.32665>:
    D.32666 = method_to_compile->klass;
    D.32667 = BIT_FIELD_REF <*D.32666, 8, 160>;
    D.32668 = D.32667 & 8;
    if (D.32668 != 0) goto <D.32657>; else goto <D.32658>;
    <D.32657>:
    D.32669 = cfg->rgctx_var;
    D.32670 = D.32669 == 0B;
    D.32671 = (long int) D.32670;
    D.32672 = __builtin_expect (D.32671, 0);
    if (D.32672 != 0) goto <D.32673>; else goto <D.32674>;
    <D.32673>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4368, "cfg->rgctx_var");
    <D.32674>:
    <D.32658>:
    gi->has_this = -1;
    D.32659 = method_to_compile->flags;
    D.32660 = (int) D.32659;
    D.32661 = D.32660 & 16;
    if (D.32661 != 0) goto <D.32675>; else goto <D.32678>;
    <D.32678>:
    D.32679 = mini_method_get_context (method_to_compile);
    D.32680 = D.32679->method_inst;
    if (D.32680 != 0B) goto <D.32675>; else goto <D.32681>;
    <D.32681>:
    D.32666 = method_to_compile->klass;
    D.32667 = BIT_FIELD_REF <*D.32666, 8, 160>;
    D.32668 = D.32667 & 8;
    if (D.32668 != 0) goto <D.32675>; else goto <D.32676>;
    <D.32675>:
    inst = cfg->rgctx_var;
    if (1 != 0) goto <D.32682>; else goto <D.32683>;
    <D.32682>:
    D.32684 = inst->opcode;
    D.32685 = D.32684 != 367;
    D.32686 = (long int) D.32685;
    D.32687 = __builtin_expect (D.32686, 0);
    if (D.32687 != 0) goto <D.32688>; else goto <D.32689>;
    <D.32688>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4378, "inst->opcode == OP_REGOFFSET");
    <D.32689>:
    <D.32683>:
    loclist = cfg->rgctx_loclist;
    goto <D.32677>;
    <D.32676>:
    D.32690 = cfg->args;
    inst = *D.32690;
    loclist = cfg->this_loclist;
    <D.32677>:
    if (loclist != 0B) goto <D.32691>; else goto <D.32692>;
    <D.32691>:
    {
      struct GSList * l;
      int i;

      D.32693 = monoeg_g_slist_length (loclist);
      D.32694 = (int) D.32693;
      gi->nlocs = D.32694;
      D.32553 = cfg->method;
      D.32615 = BIT_FIELD_REF <*D.32553, 8, 168>;
      D.32616 = D.32615 & 2;
      if (D.32616 != 0) goto <D.32695>; else goto <D.32696>;
      <D.32695>:
      D.32697 = gi->nlocs;
      D.32698 = (unsigned int) D.32697;
      D.32699 = D.32698 * 20;
      D.32700 = monoeg_malloc0 (D.32699);
      gi->locations = D.32700;
      goto <D.32701>;
      <D.32696>:
      D.32631 = cfg->domain;
      D.32697 = gi->nlocs;
      D.32698 = (unsigned int) D.32697;
      D.32699 = D.32698 * 20;
      D.32702 = mono_domain_alloc0 (D.32631, D.32699);
      gi->locations = D.32702;
      <D.32701>:
      i = 0;
      l = loclist;
      goto <D.28506>;
      <D.28505>:
      D.32703 = gi->locations;
      i.140 = (unsigned int) i;
      D.32705 = i.140 * 20;
      D.32706 = D.32703 + D.32705;
      D.32707 = l->data;
      memcpy (D.32706, D.32707, 20);
      i = i + 1;
      l = l->next;
      <D.28506>:
      if (l != 0B) goto <D.28505>; else goto <D.28507>;
      <D.28507>:
    }
    <D.32692>:
    if (0 != 0) goto <D.32708>; else goto <D.32709>;
    <D.32708>:
    D.32710 = cfg->llvm_this_reg;
    D.32711 = D.32710 == -1;
    D.32712 = (long int) D.32711;
    D.32713 = __builtin_expect (D.32712, 0);
    if (D.32713 != 0) goto <D.32714>; else goto <D.32715>;
    <D.32714>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4403, "cfg->llvm_this_reg != -1");
    <D.32715>:
    gi->this_in_reg = 0;
    D.32710 = cfg->llvm_this_reg;
    D.32716 = (unsigned char) D.32710;
    gi->this_reg = D.32716;
    D.32717 = cfg->llvm_this_offset;
    gi->this_offset = D.32717;
    goto <D.32718>;
    <D.32709>:
    D.32684 = inst->opcode;
    if (D.32684 == 366) goto <D.32719>; else goto <D.32720>;
    <D.32719>:
    gi->this_in_reg = -1;
    D.32721 = inst->dreg;
    D.32722 = (unsigned char) D.32721;
    gi->this_reg = D.32722;
    goto <D.32723>;
    <D.32720>:
    D.32684 = inst->opcode;
    D.32685 = D.32684 != 367;
    D.32686 = (long int) D.32685;
    D.32687 = __builtin_expect (D.32686, 0);
    if (D.32687 != 0) goto <D.32724>; else goto <D.32725>;
    <D.32724>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4411, "inst->opcode == OP_REGOFFSET");
    <D.32725>:
    if (0 != 0) goto <D.32726>; else goto <D.32727>;
    <D.32726>:
    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.32727>:
    gi->this_in_reg = 0;
    D.32728 = inst->sreg1;
    D.32729 = (unsigned char) D.32728;
    gi->this_reg = D.32729;
    D.32730 = inst->data.op[0].const_val;
    gi->this_offset = D.32730;
    <D.32723>:
    <D.32718>:
  }
  <D.32645>:
  if (num_holes != 0) goto <D.32731>; else goto <D.32732>;
  <D.32731>:
  {
    struct MonoTryBlockHoleTableJitInfo * table;
    int i;

    jinfo->has_try_block_holes = -1;
    table = mono_jit_info_get_try_block_hole_table_info (jinfo);
    D.32733 = (short unsigned int) num_holes;
    table->num_holes = D.32733;
    i = 0;
    tmp = cfg->try_block_holes;
    goto <D.28518>;
    <D.28517>:
    {
      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.32734 = hole_data->basic_block;
      D.32735 = D.32734->native_offset;
      D.32734 = hole_data->basic_block;
      D.32736 = D.32734->native_length;
      hole_end = D.32735 + D.32736;
      D.32582 = cfg->cil_offset_to_bb;
      D.32737 = ec->try_offset;
      D.32738 = ec->try_len;
      D.32739 = D.32737 + D.32738;
      D.32740 = D.32739 * 4;
      D.32741 = D.32582 + D.32740;
      clause_last_bb = *D.32741;
      D.32742 = clause_last_bb == 0B;
      D.32743 = (long int) D.32742;
      D.32744 = __builtin_expect (D.32743, 0);
      if (D.32744 != 0) goto <D.32745>; else goto <D.32746>;
      <D.32745>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4440, "clause_last_bb");
      <D.32746>:
      D.32747 = clause_last_bb->native_offset;
      if (D.32747 == hole_end) goto <D.32748>; else goto <D.32749>;
      <D.32748>:
      // predicted unlikely by continue predictor.
      goto <D.28516>;
      <D.32749>:
      D.32750 = hole_data->start_offset;
      D.32734 = hole_data->basic_block;
      D.32735 = D.32734->native_offset;
      D.32751 = D.32750 - D.32735;
      start_bb_offset = (guint32) D.32751;
      i.141 = i;
      i = i.141 + 1;
      hole = &table->holes[i.141];
      D.32753 = hole_data->clause;
      D.32754 = (int) D.32753;
      D.32755 = header->clauses;
      D.32756 = (int) D.32755;
      D.32757 = D.32754 - D.32756;
      D.32758 = D.32757 /[ex] 24;
      D.32759 = (short unsigned int) D.32758;
      hole->clause = D.32759;
      D.32750 = hole_data->start_offset;
      D.32760 = (unsigned int) D.32750;
      hole->offset = D.32760;
      D.32734 = hole_data->basic_block;
      D.32736 = D.32734->native_length;
      D.32761 = (short unsigned int) D.32736;
      D.32762 = (short unsigned int) start_bb_offset;
      D.32763 = D.32761 - D.32762;
      hole->length = D.32763;
      D.32601 = cfg->verbose_level;
      D.32602 = D.32601 > 3;
      D.32603 = (long int) D.32602;
      D.32604 = __builtin_expect (D.32603, 0);
      if (D.32604 != 0) goto <D.32764>; else goto <D.32765>;
      <D.32764>:
      D.32766 = hole->clause;
      D.32767 = (int) D.32766;
      D.32768 = hole->offset;
      D.32769 = hole->length;
      D.32770 = (int) D.32769;
      printf ("\tTry block hole at eh clause %d offset %x length %x\n", D.32767, D.32768, D.32770);
      <D.32765>:
    }
    <D.28516>:
    tmp = tmp->next;
    <D.28518>:
    if (tmp != 0B) goto <D.28517>; else goto <D.28519>;
    <D.28519>:
    D.32771 = i != num_holes;
    D.32772 = (long int) D.32771;
    D.32773 = __builtin_expect (D.32772, 0);
    if (D.32773 != 0) goto <D.32774>; else goto <D.32775>;
    <D.32774>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4455, "i == num_holes");
    <D.32775>:
  }
  <D.32732>:
  if (arch_eh_info_size != 0) goto <D.32776>; else goto <D.32777>;
  <D.32776>:
  {
    struct MonoArchEHJitInfo * info;

    jinfo->has_arch_eh_info = -1;
    info = mono_jit_info_get_arch_eh_info (jinfo);
    info->stack_size = stack_size;
  }
  <D.32777>:
  if (cas_size != 0) goto <D.32778>; else goto <D.32779>;
  <D.32778>:
  jinfo->has_cas_info = -1;
  <D.32779>:
  if (0 != 0) goto <D.32780>; else goto <D.32781>;
  <D.32780>:
  if (num_clauses != 0) goto <D.32782>; else goto <D.32783>;
  <D.32782>:
  D.32784 = &jinfo->clauses[0];
  D.32785 = cfg->llvm_ex_info;
  num_clauses.135 = (unsigned int) num_clauses;
  D.32620 = num_clauses.135 * 24;
  memcpy (D.32784, D.32785, D.32620);
  <D.32783>:
  goto <D.32786>;
  <D.32781>:
  D.32787 = BIT_FIELD_REF <*header, 16, 80>;
  D.32788 = D.32787 & 32767;
  if (D.32788 != 0) goto <D.32789>; else goto <D.32790>;
  <D.32789>:
  {
    int i;

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

      D.32755 = header->clauses;
      i.142 = (unsigned int) i;
      D.32792 = i.142 * 24;
      ec = D.32755 + D.32792;
      ei = &jinfo->clauses[i];
      D.32793 = ec->flags;
      ei->flags = D.32793;
      D.32794 = ec->handler_offset;
      D.32795 = (int) D.32794;
      exvar = mono_find_exvar_for_offset (cfg, D.32795);
      if (exvar != 0B) goto <D.32797>; else goto <D.32798>;
      <D.32797>:
      iftmp.143 = exvar->data.op[0].const_val;
      goto <D.32799>;
      <D.32798>:
      iftmp.143 = 0;
      <D.32799>:
      ei->exvar_offset = iftmp.143;
      D.32800 = ei->flags;
      if (D.32800 == 1) goto <D.32801>; else goto <D.32802>;
      <D.32801>:
      D.32582 = cfg->cil_offset_to_bb;
      D.32803 = ec->data.filter_offset;
      D.32804 = D.32803 * 4;
      D.32805 = D.32582 + D.32804;
      tblock = *D.32805;
      D.32806 = tblock == 0B;
      D.32807 = (long int) D.32806;
      D.32808 = __builtin_expect (D.32807, 0);
      if (D.32808 != 0) goto <D.32809>; else goto <D.32810>;
      <D.32809>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4490, "tblock");
      <D.32810>:
      D.32632 = cfg->native_code;
      D.32811 = tblock->native_offset;
      D.32812 = (sizetype) D.32811;
      D.32813 = D.32632 + D.32812;
      ei->data.filter = D.32813;
      goto <D.32814>;
      <D.32802>:
      D.32815 = ec->data.catch_class;
      ei->data.catch_class = D.32815;
      <D.32814>:
      D.32582 = cfg->cil_offset_to_bb;
      D.32816 = ec->try_offset;
      D.32817 = D.32816 * 4;
      D.32818 = D.32582 + D.32817;
      tblock = *D.32818;
      D.32806 = tblock == 0B;
      D.32807 = (long int) D.32806;
      D.32808 = __builtin_expect (D.32807, 0);
      if (D.32808 != 0) goto <D.32819>; else goto <D.32820>;
      <D.32819>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4497, "tblock");
      <D.32820>:
      D.32811 = tblock->native_offset;
      D.32821 = D.32811 == 0;
      D.32822 = (long int) D.32821;
      D.32823 = __builtin_expect (D.32822, 0);
      if (D.32823 != 0) goto <D.32824>; else goto <D.32825>;
      <D.32824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4498, "tblock->native_offset");
      <D.32825>:
      D.32632 = cfg->native_code;
      D.32811 = tblock->native_offset;
      D.32812 = (sizetype) D.32811;
      D.32813 = D.32632 + D.32812;
      ei->try_start = D.32813;
      D.32826 = BIT_FIELD_REF <*tblock, 8, 912>;
      D.32827 = D.32826 & 128;
      if (D.32827 != 0) goto <D.32828>; else goto <D.32829>;
      <D.32828>:
      D.32830 = ei->try_start;
      D.32831 = D.32830 + 4294967295;
      ei->try_start = D.32831;
      <D.32829>:
      D.32582 = cfg->cil_offset_to_bb;
      D.32816 = ec->try_offset;
      D.32832 = ec->try_len;
      D.32833 = D.32816 + D.32832;
      D.32834 = D.32833 * 4;
      D.32835 = D.32582 + D.32834;
      tblock = *D.32835;
      D.32806 = tblock == 0B;
      D.32807 = (long int) D.32806;
      D.32808 = __builtin_expect (D.32807, 0);
      if (D.32808 != 0) goto <D.32836>; else goto <D.32837>;
      <D.32836>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4508, "tblock");
      <D.32837>:
      D.32811 = tblock->native_offset;
      if (D.32811 == 0) goto <D.32838>; else goto <D.32839>;
      <D.32838>:
      {
        int j;
        int end;

        D.32816 = ec->try_offset;
        D.32832 = ec->try_len;
        D.32833 = D.32816 + D.32832;
        j = (int) D.32833;
        D.32816 = ec->try_offset;
        end = (int) D.32816;
        goto <D.28531>;
        <D.28530>:
        {
          struct MonoBasicBlock * bb;

          D.32582 = cfg->cil_offset_to_bb;
          j.144 = (unsigned int) j;
          D.32841 = j.144 * 4;
          D.32842 = D.32582 + D.32841;
          bb = *D.32842;
          if (bb != 0B) goto <D.32843>; else goto <D.32844>;
          <D.32843>:
          D.32845 = bb->native_offset;
          if (D.32845 != 0) goto <D.32846>; else goto <D.32847>;
          <D.32846>:
          tblock = bb;
          goto <D.28529>;
          <D.32847>:
          <D.32844>:
        }
        j = j + -1;
        <D.28531>:
        if (j >= end) goto <D.28530>; else goto <D.28529>;
        <D.28529>:
      }
      <D.32839>:
      D.32632 = cfg->native_code;
      D.32811 = tblock->native_offset;
      D.32812 = (sizetype) D.32811;
      D.32813 = D.32632 + D.32812;
      ei->try_end = D.32813;
      D.32811 = tblock->native_offset;
      D.32821 = D.32811 == 0;
      D.32822 = (long int) D.32821;
      D.32823 = __builtin_expect (D.32822, 0);
      if (D.32823 != 0) goto <D.32848>; else goto <D.32849>;
      <D.32848>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4520, "tblock->native_offset");
      <D.32849>:
      D.32582 = cfg->cil_offset_to_bb;
      D.32794 = ec->handler_offset;
      D.32850 = D.32794 * 4;
      D.32851 = D.32582 + D.32850;
      tblock = *D.32851;
      D.32806 = tblock == 0B;
      D.32807 = (long int) D.32806;
      D.32808 = __builtin_expect (D.32807, 0);
      if (D.32808 != 0) goto <D.32852>; else goto <D.32853>;
      <D.32852>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 4522, "tblock");
      <D.32853>:
      D.32632 = cfg->native_code;
      D.32811 = tblock->native_offset;
      D.32812 = (sizetype) D.32811;
      D.32813 = D.32632 + D.32812;
      ei->handler_start = D.32813;
      tmp = cfg->try_block_holes;
      goto <D.28536>;
      <D.28535>:
      {
        struct TryBlockHole * hole;
        void * hole_end;

        hole = tmp->data;
        D.32632 = cfg->native_code;
        D.32854 = hole->basic_block;
        D.32855 = D.32854->native_offset;
        D.32854 = hole->basic_block;
        D.32856 = D.32854->native_length;
        D.32857 = D.32855 + D.32856;
        D.32858 = (sizetype) D.32857;
        hole_end = D.32632 + D.32858;
        D.32859 = hole->clause;
        if (D.32859 == ec) goto <D.32860>; else goto <D.32861>;
        <D.32860>:
        D.32862 = ei->try_end;
        if (D.32862 == hole_end) goto <D.32863>; else goto <D.32864>;
        <D.32863>:
        D.32601 = cfg->verbose_level;
        D.32602 = D.32601 > 3;
        D.32603 = (long int) D.32602;
        D.32604 = __builtin_expect (D.32603, 0);
        if (D.32604 != 0) goto <D.32865>; else goto <D.32866>;
        <D.32865>:
        D.32862 = ei->try_end;
        D.32867 = (int) D.32862;
        D.32632 = cfg->native_code;
        D.32868 = (int) D.32632;
        D.32869 = D.32867 - D.32868;
        D.32870 = hole->start_offset;
        printf ("\tShortening try block %d from %x to %x\n", i, D.32869, D.32870);
        <D.32866>:
        D.32632 = cfg->native_code;
        D.32870 = hole->start_offset;
        D.32871 = (sizetype) D.32870;
        D.32872 = D.32632 + D.32871;
        ei->try_end = D.32872;
        goto <D.28534>;
        <D.32864>:
        <D.32861>:
      }
      tmp = tmp->next;
      <D.28536>:
      if (tmp != 0B) goto <D.28535>; else goto <D.28534>;
      <D.28534>:
      D.32793 = ec->flags;
      if (D.32793 == 2) goto <D.32873>; else goto <D.32874>;
      <D.32873>:
      {
        int end_offset;

        D.32794 = ec->handler_offset;
        D.32875 = ec->handler_len;
        D.32876 = D.32794 + D.32875;
        D.32877 = header->code_size;
        if (D.32876 < D.32877) goto <D.32878>; else goto <D.32879>;
        <D.32878>:
        D.32582 = cfg->cil_offset_to_bb;
        D.32794 = ec->handler_offset;
        D.32875 = ec->handler_len;
        D.32876 = D.32794 + D.32875;
        D.32880 = D.32876 * 4;
        D.32881 = D.32582 + D.32880;
        tblock = *D.32881;
        D.32811 = tblock->native_offset;
        if (D.32811 != 0) goto <D.32882>; else goto <D.32883>;
        <D.32882>:
        end_offset = tblock->native_offset;
        goto <D.32884>;
        <D.32883>:
        {
          int j;
          int end;

          D.32794 = ec->handler_offset;
          D.32875 = ec->handler_len;
          D.32876 = D.32794 + D.32875;
          j = (int) D.32876;
          D.32794 = ec->handler_offset;
          end = (int) D.32794;
          goto <D.28543>;
          <D.28542>:
          {
            struct MonoBasicBlock * bb;

            D.32582 = cfg->cil_offset_to_bb;
            j.145 = (unsigned int) j;
            D.32886 = j.145 * 4;
            D.32887 = D.32582 + D.32886;
            bb = *D.32887;
            if (bb != 0B) goto <D.32888>; else goto <D.32889>;
            <D.32888>:
            D.32890 = bb->native_offset;
            if (D.32890 != 0) goto <D.32891>; else goto <D.32892>;
            <D.32891>:
            tblock = bb;
            goto <D.28541>;
            <D.32892>:
            <D.32889>:
          }
          j = j + -1;
          <D.28543>:
          if (j >= end) goto <D.28542>; else goto <D.28541>;
          <D.28541>:
          D.32811 = tblock->native_offset;
          D.32893 = tblock->native_length;
          end_offset = D.32811 + D.32893;
        }
        <D.32884>:
        goto <D.32894>;
        <D.32879>:
        D.32895 = cfg->epilog_begin;
        end_offset = (int) D.32895;
        <D.32894>:
        D.32632 = cfg->native_code;
        end_offset.146 = (sizetype) end_offset;
        D.32897 = D.32632 + end_offset.146;
        ei->data.handler_end = D.32897;
      }
      <D.32874>:
    }
    i = i + 1;
    <D.28545>:
    D.32614 = header->num_clauses;
    D.32898 = (int) D.32614;
    if (D.32898 > i) goto <D.28544>; else goto <D.28546>;
    <D.28546>:
  }
  <D.32790>:
  <D.32786>:
  D.32601 = cfg->verbose_level;
  D.32602 = D.32601 > 3;
  D.32603 = (long int) D.32602;
  D.32604 = __builtin_expect (D.32603, 0);
  if (D.32604 != 0) goto <D.32899>; else goto <D.32900>;
  <D.32899>:
  {
    int i;

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

      ei = &jinfo->clauses[i];
      D.32901 = ei->try_start;
      D.32902 = (int) D.32901;
      D.32632 = cfg->native_code;
      D.32868 = (int) D.32632;
      start = D.32902 - D.32868;
      D.32903 = ei->try_end;
      D.32904 = (int) D.32903;
      D.32632 = cfg->native_code;
      D.32868 = (int) D.32632;
      end = D.32904 - D.32868;
      D.32905 = ei->handler_start;
      D.32906 = (int) D.32905;
      D.32632 = cfg->native_code;
      D.32868 = (int) D.32632;
      handler = D.32906 - D.32868;
      D.32907 = ei->data.handler_end;
      D.32908 = (int) D.32907;
      D.32632 = cfg->native_code;
      D.32868 = (int) D.32632;
      handler_end = D.32908 - D.32868;
      D.32909 = ei->flags;
      printf ("JitInfo EH clause %d flags %x try %x-%x handler %x-%x\n", i, D.32909, start, end, handler, handler_end);
    }
    i = i + 1;
    <D.28554>:
    D.32910 = jinfo->num_clauses;
    D.32911 = (int) D.32910;
    if (D.32911 > i) goto <D.28553>; else goto <D.28555>;
    <D.28555>:
  }
  <D.32900>:
  D.32912 = cfg->encoded_unwind_ops;
  if (D.32912 != 0B) goto <D.32913>; else goto <D.32914>;
  <D.32913>:
  D.32912 = cfg->encoded_unwind_ops;
  D.32915 = cfg->encoded_unwind_ops_len;
  D.32916 = mono_cache_unwind_info (D.32912, D.32915);
  jinfo->used_regs = D.32916;
  D.32912 = cfg->encoded_unwind_ops;
  monoeg_g_free (D.32912);
  goto <D.32917>;
  <D.32914>:
  D.32918 = cfg->unwind_ops;
  if (D.32918 != 0B) goto <D.32919>; else goto <D.32920>;
  <D.32919>:
  {
    guint32 info_len;
    guint8 * unwind_info;

    try
      {
        D.32918 = cfg->unwind_ops;
        unwind_info = mono_unwind_ops_encode (D.32918, &info_len);
        info_len.147 = info_len;
        D.32922 = mono_cache_unwind_info (unwind_info, info_len.147);
        jinfo->used_regs = D.32922;
        monoeg_g_free (unwind_info);
      }
    finally
      {
        info_len = {CLOBBER};
      }
  }
  <D.32920>:
  <D.32917>:
  D.32923 = jinfo;
  return D.32923;
}


mono_save_seq_point_info (struct MonoCompile * cfg)
{
  struct GPtrArray * D.32925;
  unsigned int D.32928;
  unsigned int D.32929;
  unsigned int D.32930;
  int D.32931;
  void * * D.32932;
  unsigned int i.148;
  unsigned int D.32934;
  void * * D.32935;
  int D.32936;
  int D.32937;
  unsigned char D.32938;
  int D.32939;
  int D.32940;
  int D.32943;
  int D.32944;
  unsigned int i.149;
  unsigned int D.32946;
  struct GSList * D.32947;
  int D.32948;
  _Bool D.32949;
  _Bool D.32950;
  _Bool D.32951;
  int D.32954;
  int D.32959;
  unsigned int D.32960;
  unsigned int D.32961;
  struct GSList * * D.32962;
  struct GSList * D.32963;
  int D.32964;
  void * D.32965;
  struct GSList * D.32966;
  struct MonoInst * D.32968;
  short unsigned int D.32971;
  struct GSList * D.32978;
  int D.32981;
  _Bool D.32982;
  _Bool D.32983;
  _Bool D.32984;
  int D.32989;
  unsigned int D.32990;
  unsigned int D.32991;
  struct GSList * * D.32992;
  struct GSList * D.32993;
  int D.32994;
  void * D.32995;
  struct GSList * D.32996;
  unsigned int D.32997;
  struct GSList * * D.33000;
  struct GSList * D.33001;
  unsigned int D.33002;
  int D.33003;
  int D.33004;
  unsigned int D.33005;
  unsigned int D.33006;
  void * D.33007;
  int D.33012;
  void * D.33013;
  int D.33014;
  int * D.33015;
  int j.150;
  unsigned int j.151;
  unsigned int D.33018;
  int * D.33019;
  unsigned char D.33020;
  unsigned char D.33021;
  union mono_mutex_t * D.33024;
  _Bool D.33027;
  long int D.33028;
  long int D.33029;
  void * D.33032;
  struct GHashTable * D.33033;
  struct MonoMethod * D.33034;
  void * D.33035;
  _Bool D.33040;
  long int D.33041;
  long int D.33042;
  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.32925 = cfg->seq_points;
  if (D.32925 == 0B) goto <D.32926>; else goto <D.32927>;
  <D.32926>:
  return;
  <D.32927>:
  D.32925 = cfg->seq_points;
  D.32928 = D.32925->len;
  D.32929 = D.32928 * 20;
  D.32930 = D.32929 + 4;
  info = monoeg_malloc0 (D.32930);
  D.32925 = cfg->seq_points;
  D.32928 = D.32925->len;
  D.32931 = (int) D.32928;
  info->len = D.32931;
  i = 0;
  goto <D.28403>;
  <D.28402>:
  {
    struct SeqPoint * sp;
    struct MonoInst * ins;

    sp = &info->seq_points[i];
    D.32925 = cfg->seq_points;
    D.32932 = D.32925->pdata;
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.32935 = D.32932 + D.32934;
    ins = *D.32935;
    D.32936 = ins->data.op[1].const_val;
    sp->il_offset = D.32936;
    D.32937 = ins->data.op[0].const_val;
    sp->native_offset = D.32937;
    D.32938 = ins->flags;
    D.32939 = (int) D.32938;
    D.32940 = D.32939 & 4;
    if (D.32940 != 0) goto <D.32941>; else goto <D.32942>;
    <D.32941>:
    D.32943 = sp->flags;
    D.32944 = D.32943 | 1;
    sp->flags = D.32944;
    <D.32942>:
    ins->backend.size = i;
  }
  i = i + 1;
  <D.28403>:
  i.149 = (unsigned int) i;
  D.32925 = cfg->seq_points;
  D.32928 = D.32925->len;
  if (i.149 < D.32928) goto <D.28402>; else goto <D.28404>;
  <D.28404>:
  D.32925 = cfg->seq_points;
  D.32928 = D.32925->len;
  D.32946 = D.32928 * 4;
  next = monoeg_malloc0 (D.32946);
  bb = cfg->bb_entry;
  goto <D.28418>;
  <D.28417>:
  D.32947 = bb->seq_points;
  bb_seq_points = monoeg_g_slist_reverse (D.32947);
  last = 0B;
  l = bb_seq_points;
  goto <D.28408>;
  <D.28407>:
  {
    struct MonoInst * ins;

    ins = l->data;
    D.32948 = ins->data.op[1].const_val;
    D.32949 = D.32948 == -1;
    D.32950 = D.32948 == 16777215;
    D.32951 = D.32949 | D.32950;
    if (D.32951 != 0) goto <D.32952>; else goto <D.32953>;
    <D.32952>:
    // predicted unlikely by continue predictor.
    goto <D.28406>;
    <D.32953>:
    D.32954 = ins->data.op[0].const_val;
    if (D.32954 == -1) goto <D.32955>; else goto <D.32956>;
    <D.32955>:
    // predicted unlikely by continue predictor.
    goto <D.28406>;
    <D.32956>:
    if (last != 0B) goto <D.32957>; else goto <D.32958>;
    <D.32957>:
    D.32959 = last->backend.size;
    D.32960 = (unsigned int) D.32959;
    D.32961 = D.32960 * 4;
    D.32962 = next + D.32961;
    D.32959 = last->backend.size;
    D.32960 = (unsigned int) D.32959;
    D.32961 = D.32960 * 4;
    D.32962 = next + D.32961;
    D.32963 = *D.32962;
    D.32964 = ins->backend.size;
    D.32965 = (void *) D.32964;
    D.32966 = monoeg_g_slist_append (D.32963, D.32965);
    *D.32962 = D.32966;
    goto <D.32967>;
    <D.32958>:
    collect_pred_seq_points (bb, ins, next, 0);
    <D.32967>:
    last = ins;
  }
  <D.28406>:
  l = l->next;
  <D.28408>:
  if (l != 0B) goto <D.28407>; else goto <D.28409>;
  <D.28409>:
  D.32968 = bb->last_ins;
  if (D.32968 != 0B) goto <D.32969>; else goto <D.32970>;
  <D.32969>:
  D.32968 = bb->last_ins;
  D.32971 = D.32968->opcode;
  if (D.32971 == 738) goto <D.32972>; else goto <D.32973>;
  <D.32972>:
  D.32947 = bb->seq_points;
  if (D.32947 != 0B) goto <D.32974>; else goto <D.32975>;
  <D.32974>:
  {
    struct MonoBasicBlock * bb2;
    struct MonoInst * endfinally_seq_point;

    endfinally_seq_point = 0B;
    D.32947 = bb->seq_points;
    l = monoeg_g_slist_last (D.32947);
    if (l != 0B) goto <D.32976>; else goto <D.32977>;
    <D.32976>:
    endfinally_seq_point = l->data;
    bb2 = cfg->bb_entry;
    goto <D.28415>;
    <D.28414>:
    {
      struct GSList * l;

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

        ins = l->data;
        D.32981 = ins->data.op[1].const_val;
        D.32982 = D.32981 != -1;
        D.32983 = D.32981 != 16777215;
        D.32984 = D.32982 & D.32983;
        if (D.32984 != 0) goto <D.32985>; else goto <D.32986>;
        <D.32985>:
        if (ins != endfinally_seq_point) goto <D.32987>; else goto <D.32988>;
        <D.32987>:
        D.32989 = endfinally_seq_point->backend.size;
        D.32990 = (unsigned int) D.32989;
        D.32991 = D.32990 * 4;
        D.32992 = next + D.32991;
        D.32989 = endfinally_seq_point->backend.size;
        D.32990 = (unsigned int) D.32989;
        D.32991 = D.32990 * 4;
        D.32992 = next + D.32991;
        D.32993 = *D.32992;
        D.32994 = ins->backend.size;
        D.32995 = (void *) D.32994;
        D.32996 = monoeg_g_slist_append (D.32993, D.32995);
        *D.32992 = D.32996;
        <D.32988>:
        <D.32986>:
      }
      <D.32980>:
    }
    bb2 = bb2->next_bb;
    <D.28415>:
    if (bb2 != 0B) goto <D.28414>; else goto <D.28416>;
    <D.28416>:
    <D.32977>:
  }
  <D.32975>:
  <D.32973>:
  <D.32970>:
  bb = bb->next_bb;
  <D.28418>:
  if (bb != 0B) goto <D.28417>; else goto <D.28419>;
  <D.28419>:
  D.32997 = cfg->verbose_level;
  if (D.32997 > 2) goto <D.32998>; else goto <D.32999>;
  <D.32998>:
  printf ("\nSEQ POINT MAP: \n");
  <D.32999>:
  i = 0;
  goto <D.28431>;
  <D.28430>:
  {
    struct SeqPoint * sp;
    struct GSList * l;
    int j;
    int next_index;

    sp = &info->seq_points[i];
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.33000 = next + D.32934;
    D.33001 = *D.33000;
    D.33002 = monoeg_g_slist_length (D.33001);
    D.33003 = (int) D.33002;
    sp->next_len = D.33003;
    D.33004 = sp->next_len;
    D.33005 = (unsigned int) D.33004;
    D.33006 = D.33005 * 4;
    D.33007 = monoeg_malloc (D.33006);
    sp->next = D.33007;
    j = 0;
    D.32997 = cfg->verbose_level;
    if (D.32997 > 2) goto <D.33008>; else goto <D.33009>;
    <D.33008>:
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.33000 = next + D.32934;
    D.33001 = *D.33000;
    if (D.33001 != 0B) goto <D.33010>; else goto <D.33011>;
    <D.33010>:
    D.33012 = sp->il_offset;
    printf ("\tIL0x%x ->", D.33012);
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.33000 = next + D.32934;
    l = *D.33000;
    goto <D.28425>;
    <D.28424>:
    D.33013 = l->data;
    next_index = (int) D.33013;
    D.33014 = info->seq_points[next_index].il_offset;
    printf (" IL0x%x", D.33014);
    l = l->next;
    <D.28425>:
    if (l != 0B) goto <D.28424>; else goto <D.28426>;
    <D.28426>:
    printf ("\n");
    <D.33011>:
    <D.33009>:
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.33000 = next + D.32934;
    l = *D.33000;
    goto <D.28428>;
    <D.28427>:
    D.33013 = l->data;
    next_index = (int) D.33013;
    D.33015 = sp->next;
    j.150 = j;
    j = j.150 + 1;
    j.151 = (unsigned int) j.150;
    D.33018 = j.151 * 4;
    D.33019 = D.33015 + D.33018;
    *D.33019 = next_index;
    l = l->next;
    <D.28428>:
    if (l != 0B) goto <D.28427>; else goto <D.28429>;
    <D.28429>:
    i.148 = (unsigned int) i;
    D.32934 = i.148 * 4;
    D.33000 = next + D.32934;
    D.33001 = *D.33000;
    monoeg_g_slist_free (D.33001);
  }
  i = i + 1;
  <D.28431>:
  i.149 = (unsigned int) i;
  D.32925 = cfg->seq_points;
  D.32928 = D.32925->len;
  if (i.149 < D.32928) goto <D.28430>; else goto <D.28432>;
  <D.28432>:
  monoeg_g_free (next);
  cfg->seq_point_info = info;
  D.33020 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.33021 = D.33020 & 64;
  if (D.33021 == 0) goto <D.33022>; else goto <D.33023>;
  <D.33022>:
  {
    int ret;

    D.33024 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.33024);
    if (ret != 0) goto <D.33025>; else goto <D.33026>;
    <D.33025>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33026>:
    D.33027 = ret != 0;
    D.33028 = (long int) D.33027;
    D.33029 = __builtin_expect (D.33028, 0);
    if (D.33029 != 0) goto <D.33030>; else goto <D.33031>;
    <D.33030>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3994, "ret == 0");
    <D.33031>:
  }
  D.33032 = domain->runtime_info;
  D.33033 = MEM[(struct MonoJitDomainInfo *)D.33032].seq_points;
  D.33034 = cfg->method_to_register;
  D.33035 = monoeg_g_hash_table_lookup (D.33033, D.33034);
  if (D.33035 == 0B) goto <D.33036>; else goto <D.33037>;
  <D.33036>:
  D.33032 = domain->runtime_info;
  D.33033 = MEM[(struct MonoJitDomainInfo *)D.33032].seq_points;
  D.33034 = cfg->method_to_register;
  monoeg_g_hash_table_insert_replace (D.33033, D.33034, info, 0);
  <D.33037>:
  {
    int ret;

    D.33024 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.33024);
    if (ret != 0) goto <D.33038>; else goto <D.33039>;
    <D.33038>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33039>:
    D.33040 = ret != 0;
    D.33041 = (long int) D.33040;
    D.33042 = __builtin_expect (D.33041, 0);
    if (D.33042 != 0) goto <D.33043>; else goto <D.33044>;
    <D.33043>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 3998, "ret == 0");
    <D.33044>:
  }
  <D.33023>:
  D.32925 = cfg->seq_points;
  monoeg_g_ptr_array_free (D.32925, 1);
  cfg->seq_points = 0B;
}


collect_pred_seq_points (struct MonoBasicBlock * bb, struct MonoInst * ins, struct GSList * * next, int depth)
{
  struct MonoBasicBlock * * D.33046;
  unsigned int i.152;
  unsigned int D.33048;
  struct MonoBasicBlock * * D.33049;
  struct MonoInst * D.33050;
  unsigned int src_index.153;
  unsigned int D.33054;
  struct GSList * * D.33055;
  void * D.33056;
  unsigned int D.33057;
  unsigned int dst_index.154;
  struct GSList * D.33062;
  void * dst_index.155;
  struct GSList * D.33064;
  int D.33068;
  short int D.33069;
  int D.33070;
  int i;
  struct MonoBasicBlock * in_bb;
  struct GSList * l;

  i = 0;
  goto <D.28387>;
  <D.28386>:
  D.33046 = bb->in_bb;
  i.152 = (unsigned int) i;
  D.33048 = i.152 * 4;
  D.33049 = D.33046 + D.33048;
  in_bb = *D.33049;
  D.33050 = in_bb->last_seq_point;
  if (D.33050 != 0B) goto <D.33051>; else goto <D.33052>;
  <D.33051>:
  {
    int src_index;
    int dst_index;

    D.33050 = in_bb->last_seq_point;
    src_index = D.33050->backend.size;
    dst_index = ins->backend.size;
    src_index.153 = (unsigned int) src_index;
    D.33054 = src_index.153 * 4;
    D.33055 = next + D.33054;
    l = *D.33055;
    goto <D.28385>;
    <D.28384>:
    D.33056 = l->data;
    D.33057 = (unsigned int) D.33056;
    dst_index.154 = (unsigned int) dst_index;
    if (D.33057 == dst_index.154) goto <D.28383>; else goto <D.33059>;
    <D.33059>:
    l = l->next;
    <D.28385>:
    if (l != 0B) goto <D.28384>; else goto <D.28383>;
    <D.28383>:
    if (l == 0B) goto <D.33060>; else goto <D.33061>;
    <D.33060>:
    src_index.153 = (unsigned int) src_index;
    D.33054 = src_index.153 * 4;
    D.33055 = next + D.33054;
    src_index.153 = (unsigned int) src_index;
    D.33054 = src_index.153 * 4;
    D.33055 = next + D.33054;
    D.33062 = *D.33055;
    dst_index.155 = (void *) dst_index;
    D.33064 = monoeg_g_slist_append (D.33062, dst_index.155);
    *D.33055 = D.33064;
    <D.33061>:
  }
  goto <D.33065>;
  <D.33052>:
  if (depth <= 4) goto <D.33066>; else goto <D.33067>;
  <D.33066>:
  D.33068 = depth + 1;
  collect_pred_seq_points (in_bb, ins, next, D.33068);
  <D.33067>:
  <D.33065>:
  i = i + 1;
  <D.28387>:
  D.33069 = bb->in_count;
  D.33070 = (int) D.33069;
  if (D.33070 > i) goto <D.28386>; else goto <D.28388>;
  <D.28388>:
}


mono_domain_lookup_shared_generic (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.33071;
  struct MonoMethod * D.33072;
  unsigned char D.33075;
  unsigned char D.33076;
  int inited.156;
  int lookups.157;
  int lookups.158;
  int failed_lookups.159;
  int failed_lookups.160;
  struct MonoJitInfo * D.33088;
  static gboolean inited = 0;
  static int lookups = 0;
  static int failed_lookups = 0;
  struct MonoJitInfo * ji;

  D.33071 = &domain->jit_code_hash;
  D.33072 = mini_get_shared_method (method);
  ji = mono_internal_hash_table_lookup (D.33071, D.33072);
  if (ji != 0B) goto <D.33073>; else goto <D.33074>;
  <D.33073>:
  D.33075 = BIT_FIELD_REF <*ji, 8, 176>;
  D.33076 = D.33075 & 2;
  if (D.33076 == 0) goto <D.33077>; else goto <D.33078>;
  <D.33077>:
  ji = 0B;
  <D.33078>:
  <D.33074>:
  inited.156 = inited;
  if (inited.156 == 0) goto <D.33080>; else goto <D.33081>;
  <D.33080>:
  mono_counters_register ("Shared generic lookups", 2048, &lookups);
  mono_counters_register ("Failed shared generic lookups", 2048, &failed_lookups);
  inited = 1;
  <D.33081>:
  lookups.157 = lookups;
  lookups.158 = lookups.157 + 1;
  lookups = lookups.158;
  if (ji == 0B) goto <D.33084>; else goto <D.33085>;
  <D.33084>:
  failed_lookups.159 = failed_lookups;
  failed_lookups.160 = failed_lookups.159 + 1;
  failed_lookups = failed_lookups.160;
  <D.33085>:
  D.33088 = ji;
  return D.33088;
}


mono_enable_jit_map ()
{
  struct FILE * perf_map_file.161;
  int D.33093;
  struct FILE * perf_map_file.162;

  perf_map_file.161 = perf_map_file;
  if (perf_map_file.161 == 0B) goto <D.33091>; else goto <D.33092>;
  <D.33091>:
  {
    char name[64];

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


mono_emit_jit_tramp (void * start, int size, const char * desc)
{
  struct FILE * perf_map_file.163;
  unsigned int start.164;
  long long unsigned int D.33099;

  perf_map_file.163 = perf_map_file;
  if (perf_map_file.163 != 0B) goto <D.33096>; else goto <D.33097>;
  <D.33096>:
  perf_map_file.163 = perf_map_file;
  start.164 = (unsigned int) start;
  D.33099 = (long long unsigned int) start.164;
  fprintf (perf_map_file.163, "%llx %x %s\n", D.33099, size, desc);
  <D.33097>:
}


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

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


mono_emit_jit_map (struct MonoJitInfo * jinfo)
{
  struct FILE * perf_map_file.165;
  struct MonoMethod * D.33105;
  void * D.33106;
  int D.33107;

  perf_map_file.165 = perf_map_file;
  if (perf_map_file.165 != 0B) goto <D.33103>; else goto <D.33104>;
  <D.33103>:
  {
    char * name;

    D.33105 = jinfo_get_method (jinfo);
    name = mono_method_full_name (D.33105, 1);
    D.33106 = jinfo->code_start;
    D.33107 = jinfo->code_size;
    mono_emit_jit_tramp (D.33106, D.33107, name);
    monoeg_g_free (name);
  }
  <D.33104>:
}


mono_jit_map_is_enabled ()
{
  gboolean D.33108;
  struct FILE * perf_map_file.166;
  _Bool D.33110;

  perf_map_file.166 = perf_map_file;
  D.33110 = perf_map_file.166 != 0B;
  D.33108 = (gboolean) D.33110;
  return D.33108;
}


mono_jit_compile_method (struct MonoMethod * method)
{
  unsigned int default_opt.167;
  unsigned int D.33113;
  struct MonoException * ex.168;
  _Bool D.33117;
  long int D.33118;
  long int D.33119;
  void * D.33122;
  struct MonoException * ex;
  void * code;

  try
    {
      ex = 0B;
      default_opt.167 = default_opt;
      D.33113 = mono_get_optimizations_for_method (method, default_opt.167);
      code = mono_jit_compile_method_with_opt (method, D.33113, &ex);
      if (code == 0B) goto <D.33114>; else goto <D.33115>;
      <D.33114>:
      ex.168 = ex;
      D.33117 = ex.168 == 0B;
      D.33118 = (long int) D.33117;
      D.33119 = __builtin_expect (D.33118, 0);
      if (D.33119 != 0) goto <D.33120>; else goto <D.33121>;
      <D.33120>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6250, "ex");
      <D.33121>:
      ex.168 = ex;
      mono_raise_exception (ex.168);
      <D.33115>:
      D.33122 = code;
      return D.33122;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_jit_compile_method_with_opt (struct MonoMethod * method, guint32 opt, struct MonoException * * ex)
{
  unsigned char D.33125;
  unsigned char D.33126;
  <unnamed type> D.33131;
  void * D.33134;
  _Bool D.33135;
  long int D.33136;
  long int D.33137;
  unsigned char D.33140;
  unsigned char D.33141;
  struct MonoClass * D.33146;
  struct MonoImage * D.33147;
  struct MonoImage * D.33148;
  unsigned char D.33150;
  unsigned int D.33151;
  _Bool D.33157;
  long int D.33158;
  long int D.33159;
  <unnamed type> D.33162;
  unsigned char D.33174;
  unsigned char D.33175;
  int D.33176;
  int D.33177;
  _Bool D.33178;
  long int D.33179;
  long int D.33180;
  _Bool D.33183;
  int D.33184;
  void * D.33187;
  void * D.33188;
  int opt.169;
  unsigned char D.33192;
  _Bool D.33193;
  _Bool D.33194;
  _Bool D.33195;
  struct MonoDomain * D.33198;
  _Bool D.33199;
  long int D.33200;
  long int D.33201;
  _Bool D.33208;
  long int D.33209;
  long int D.33210;
  const void * D.33213;
  _Bool D.33218;
  long int D.33219;
  long int D.33220;
  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.33125 = BIT_FIELD_REF <*method, 8, 160>;
  D.33126 = D.33125 & 124;
  if (D.33126 == 24) goto <D.33127>; else goto <D.33128>;
  <D.33127>:
  winfo = mono_marshal_get_wrapper_info (method);
  <D.33128>:
  if (winfo != 0B) goto <D.33129>; else goto <D.33130>;
  <D.33129>:
  D.33131 = winfo->subtype;
  if (D.33131 == 15) goto <D.33132>; else goto <D.33133>;
  <D.33132>:
  D.33134 = winfo->d.icall.func;
  callinfo = mono_find_jit_icall_by_addr (D.33134);
  D.33135 = callinfo == 0B;
  D.33136 = (long int) D.33135;
  D.33137 = __builtin_expect (D.33136, 0);
  if (D.33137 != 0) goto <D.33138>; else goto <D.33139>;
  <D.33138>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6160, "callinfo");
  <D.33139>:
  opt = opt | 512;
  <D.33133>:
  <D.33130>:
  D.33140 = BIT_FIELD_REF <*method, 8, 168>;
  D.33141 = D.33140 & 2;
  if (D.33141 != 0) goto <D.33142>; else goto <D.33143>;
  <D.33142>:
  opt = opt & 4294966783;
  <D.33143>:
  D.33146 = method->klass;
  D.33147 = D.33146->image;
  D.33148 = mono_get_corlib ();
  if (D.33147 != D.33148) goto <D.33144>; else goto <D.33149>;
  <D.33149>:
  D.33140 = BIT_FIELD_REF <*method, 8, 168>;
  D.33150 = D.33140 & 16;
  if (D.33150 != 0) goto <D.33144>; else goto <D.33145>;
  <D.33144>:
  opt = opt & 4294966783;
  <D.33145>:
  D.33151 = opt & 512;
  if (D.33151 != 0) goto <D.33152>; else goto <D.33153>;
  <D.33152>:
  target_domain = mono_get_root_domain ();
  goto <D.33154>;
  <D.33153>:
  target_domain = domain;
  <D.33154>:
  D.33125 = BIT_FIELD_REF <*method, 8, 160>;
  D.33126 = D.33125 & 124;
  if (D.33126 == 100) goto <D.33155>; else goto <D.33156>;
  <D.33155>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    D.33157 = info == 0B;
    D.33158 = (long int) D.33157;
    D.33159 = __builtin_expect (D.33158, 0);
    if (D.33159 != 0) goto <D.33160>; else goto <D.33161>;
    <D.33160>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6181, "info");
    <D.33161>:
    D.33162 = info->subtype;
    if (D.33162 == 17) goto <D.33163>; else goto <D.33164>;
    <D.33163>:
    {
      struct MonoGenericContext * ctx;

      ctx = 0B;
      D.33140 = BIT_FIELD_REF <*method, 8, 168>;
      D.33150 = D.33140 & 16;
      if (D.33150 != 0) goto <D.33165>; else goto <D.33166>;
      <D.33165>:
      ctx = mono_method_get_context (method);
      <D.33166>:
      method = info->d.synchronized_inner.method;
      if (ctx != 0B) goto <D.33167>; else goto <D.33168>;
      <D.33167>:
      method = mono_class_inflate_generic_method (method, ctx);
      <D.33168>:
    }
    <D.33164>:
  }
  <D.33156>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.33169>; else goto <D.33170>;
  <D.33169>:
  if (domain == target_domain) goto <D.33171>; else goto <D.33173>;
  <D.33173>:
  D.33174 = BIT_FIELD_REF <*info, 8, 168>;
  D.33175 = D.33174 & 128;
  if (D.33175 != 0) goto <D.33171>; else goto <D.33172>;
  <D.33171>:
  {
    struct MonoVTable * vtable;
    struct MonoException * tmpEx;

    D.33176 = mono_jit_stats.methods_lookups;
    D.33177 = D.33176 + 1;
    mono_jit_stats.methods_lookups = D.33177;
    D.33146 = method->klass;
    vtable = mono_class_vtable (domain, D.33146);
    D.33178 = vtable == 0B;
    D.33179 = (long int) D.33178;
    D.33180 = __builtin_expect (D.33179, 0);
    if (D.33180 != 0) goto <D.33181>; else goto <D.33182>;
    <D.33181>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6201, "vtable");
    <D.33182>:
    D.33183 = ex == 0B;
    D.33184 = (int) D.33183;
    tmpEx = mono_runtime_class_init_full (vtable, D.33184);
    if (tmpEx != 0B) goto <D.33185>; else goto <D.33186>;
    <D.33185>:
    *ex = tmpEx;
    D.33187 = 0B;
    return D.33187;
    <D.33186>:
    D.33188 = info->code_start;
    D.33187 = mono_create_ftnptr (target_domain, D.33188);
    return D.33187;
  }
  <D.33172>:
  <D.33170>:
  opt.169 = (int) opt;
  code = mono_jit_compile_method_inner (method, target_domain, opt.169, ex);
  if (code == 0B) goto <D.33190>; else goto <D.33191>;
  <D.33190>:
  D.33187 = 0B;
  return D.33187;
  <D.33191>:
  D.33125 = BIT_FIELD_REF <*method, 8, 160>;
  D.33192 = D.33125 & 124;
  D.33193 = D.33192 == 96;
  D.33194 = D.33192 == 112;
  D.33195 = D.33193 | D.33194;
  if (D.33195 != 0) goto <D.33196>; else goto <D.33197>;
  <D.33196>:
  {
    struct MonoDomain * d;

    try
      {
        D.33198 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.33198, code, &d);
        D.33199 = ji == 0B;
        D.33200 = (long int) D.33199;
        D.33201 = __builtin_expect (D.33200, 0);
        if (D.33201 != 0) goto <D.33202>; else goto <D.33203>;
        <D.33202>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6222, "ji");
        <D.33203>:
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.33197>:
  p = mono_create_ftnptr (target_domain, code);
  if (callinfo != 0B) goto <D.33204>; else goto <D.33205>;
  <D.33204>:
  mono_loader_lock ();
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.33206>; else goto <D.33207>;
    <D.33206>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33207>:
    D.33208 = ret != 0;
    D.33209 = (long int) D.33208;
    D.33210 = __builtin_expect (D.33209, 0);
    if (D.33210 != 0) goto <D.33211>; else goto <D.33212>;
    <D.33211>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6230, "ret == 0");
    <D.33212>:
  }
  D.33213 = callinfo->wrapper;
  if (D.33213 == 0B) goto <D.33214>; else goto <D.33215>;
  <D.33214>:
  callinfo->wrapper = p;
  mono_register_jit_icall_wrapper (callinfo, p);
  <D.33215>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.33216>; else goto <D.33217>;
    <D.33216>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33217>:
    D.33218 = ret != 0;
    D.33219 = (long int) D.33218;
    D.33220 = __builtin_expect (D.33219, 0);
    if (D.33220 != 0) goto <D.33221>; else goto <D.33222>;
    <D.33221>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6235, "ret == 0");
    <D.33222>:
  }
  mono_loader_unlock ();
  <D.33205>:
  D.33187 = p;
  return D.33187;
}


lookup_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.33224;
  _Bool D.33227;
  long int D.33228;
  long int D.33229;
  _Bool D.33234;
  long int D.33235;
  long int D.33236;
  struct MonoJitInfo * D.33239;
  struct MonoJitInfo * info;

  mono_loader_lock ();
  {
    int ret;

    D.33224 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.33224);
    if (ret != 0) goto <D.33225>; else goto <D.33226>;
    <D.33225>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33226>:
    D.33227 = ret != 0;
    D.33228 = (long int) D.33227;
    D.33229 = __builtin_expect (D.33228, 0);
    if (D.33229 != 0) goto <D.33230>; else goto <D.33231>;
    <D.33230>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5750, "ret == 0");
    <D.33231>:
  }
  info = lookup_method_inner (domain, method);
  {
    int ret;

    D.33224 = &domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.33224);
    if (ret != 0) goto <D.33232>; else goto <D.33233>;
    <D.33232>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33233>:
    D.33234 = ret != 0;
    D.33235 = (long int) D.33234;
    D.33236 = __builtin_expect (D.33235, 0);
    if (D.33236 != 0) goto <D.33237>; else goto <D.33238>;
    <D.33237>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5752, "ret == 0");
    <D.33238>:
  }
  mono_loader_unlock ();
  D.33239 = info;
  return D.33239;
}


lookup_method_inner (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoInternalHashTable * D.33241;
  struct MonoJitInfo * D.33244;
  int D.33245;
  struct MonoJitInfo * ji;

  D.33241 = &domain->jit_code_hash;
  ji = mono_internal_hash_table_lookup (D.33241, method);
  if (ji != 0B) goto <D.33242>; else goto <D.33243>;
  <D.33242>:
  D.33244 = ji;
  return D.33244;
  <D.33243>:
  D.33245 = mono_method_is_generic_sharable (method, 0);
  if (D.33245 == 0) goto <D.33246>; else goto <D.33247>;
  <D.33246>:
  D.33244 = 0B;
  return D.33244;
  <D.33247>:
  D.33244 = mono_domain_lookup_shared_generic (domain, method);
  return D.33244;
}


mono_jit_compile_method_inner (struct MonoMethod * method, struct MonoDomain * target_domain, int opt, struct MonoException * * jit_ex)
{
  int D.33249;
  struct MonoMethod * method.170;
  struct MonoClass * D.33253;
  _Bool D.33256;
  long int D.33257;
  long int D.33258;
  void * D.33261;
  short unsigned int D.33264;
  int D.33265;
  int D.33266;
  short unsigned int D.33268;
  int D.33269;
  int D.33270;
  void * D.33271;
  void * D.33276;
  int D.33278;
  char * D.33281;
  struct MonoImage * D.33282;
  char * D.33283;
  int check_for_pending_exc.171;
  void * D.33286;
  struct MonoDomain * D.33289;
  int D.33292;
  struct MonoClass * D.33295;
  struct MonoClass * D.33296;
  char D.33300;
  int D.28790;
  int iftmp.172;
  int D.28789;
  const char[6] * D.33305;
  unsigned char D.33306;
  int D.33307;
  unsigned char D.33308;
  int D.33309;
  _Bool D.33310;
  _Bool D.33311;
  _Bool D.33312;
  const unsigned char * D.33315;
  unsigned char D.33316;
  int D.33317;
  const unsigned char * D.33318;
  unsigned char D.33319;
  int D.33320;
  _Bool D.33321;
  _Bool D.33322;
  const unsigned char * D.33325;
  unsigned char D.33326;
  int D.33327;
  const unsigned char * D.33328;
  unsigned char D.33329;
  int D.33330;
  _Bool D.33331;
  _Bool D.33332;
  const unsigned char * D.33335;
  unsigned char D.33336;
  int D.33337;
  const unsigned char * D.33338;
  unsigned char D.33339;
  int D.33340;
  _Bool D.33343;
  long int D.33344;
  long int D.33345;
  const void * D.33348;
  int D.28800;
  int iftmp.173;
  int D.28799;
  const char[7] * D.33354;
  unsigned char D.33355;
  int D.33356;
  unsigned char D.33357;
  int D.33358;
  _Bool D.33359;
  _Bool D.33360;
  _Bool D.33361;
  const unsigned char * D.33364;
  unsigned char D.33365;
  int D.33366;
  const unsigned char * D.33367;
  unsigned char D.33368;
  int D.33369;
  _Bool D.33370;
  _Bool D.33371;
  const unsigned char * D.33374;
  unsigned char D.33375;
  int D.33376;
  const unsigned char * D.33377;
  unsigned char D.33378;
  int D.33379;
  _Bool D.33380;
  _Bool D.33381;
  const unsigned char * D.33384;
  unsigned char D.33385;
  int D.33386;
  const unsigned char * D.33387;
  unsigned char D.33388;
  int D.33389;
  int D.28809;
  int iftmp.174;
  int D.28808;
  const char[12] * D.33397;
  unsigned char D.33398;
  int D.33399;
  unsigned char D.33400;
  int D.33401;
  _Bool D.33402;
  _Bool D.33403;
  _Bool D.33404;
  const unsigned char * D.33407;
  unsigned char D.33408;
  int D.33409;
  const unsigned char * D.33410;
  unsigned char D.33411;
  int D.33412;
  _Bool D.33413;
  _Bool D.33414;
  const unsigned char * D.33417;
  unsigned char D.33418;
  int D.33419;
  const unsigned char * D.33420;
  unsigned char D.33421;
  int D.33422;
  _Bool D.33423;
  _Bool D.33424;
  const unsigned char * D.33427;
  unsigned char D.33428;
  int D.33429;
  const unsigned char * D.33430;
  unsigned char D.33431;
  int D.33432;
  void * D.33435;
  int D.28818;
  int iftmp.175;
  int D.28817;
  const char[10] * D.33441;
  unsigned char D.33442;
  int D.33443;
  unsigned char D.33444;
  int D.33445;
  _Bool D.33446;
  _Bool D.33447;
  _Bool D.33448;
  const unsigned char * D.33451;
  unsigned char D.33452;
  int D.33453;
  const unsigned char * D.33454;
  unsigned char D.33455;
  int D.33456;
  _Bool D.33457;
  _Bool D.33458;
  const unsigned char * D.33461;
  unsigned char D.33462;
  int D.33463;
  const unsigned char * D.33464;
  unsigned char D.33465;
  int D.33466;
  _Bool D.33467;
  _Bool D.33468;
  const unsigned char * D.33471;
  unsigned char D.33472;
  int D.33473;
  const unsigned char * D.33474;
  unsigned char D.33475;
  int D.33476;
  void * D.33480;
  struct MonoImage * D.33481;
  struct MonoException * D.33482;
  unsigned char D.33483;
  unsigned char D.33484;
  <unnamed type> D.33487;
  unsigned int D.33488;
  _Bool D.33491;
  struct MonoTrampInfo * in_tinfo.176;
  struct MonoTrampInfo * out_tinfo.177;
  int mono_aot_only.178;
  const char * iftmp.179;
  struct MonoTrampInfo * tinfo.180;
  struct MonoDomain * D.33510;
  struct MonoException * D.33516;
  unsigned int opt.181;
  double D.33518;
  double D.33519;
  double D.33520;
  unsigned int D.33521;
  void * D.33525;
  char * D.33531;
  guint32 * D.33545;
  struct MonoMethod * D.33546;
  void * * D.33547;
  struct MonoDomain * D.33548;
  unsigned int D.33551;
  unsigned int D.33552;
  union mono_mutex_t * D.33555;
  _Bool D.33558;
  long int D.33559;
  long int D.33560;
  union mono_mutex_t * D.33563;
  _Bool D.33566;
  long int D.33567;
  long int D.33568;
  struct MonoDomain * D.33575;
  unsigned char D.33577;
  unsigned char D.33578;
  struct MonoInternalHashTable * D.33581;
  struct MonoJitInfo * D.33582;
  struct MonoMethod * D.33583;
  _Bool D.33586;
  long int D.33587;
  long int D.33588;
  struct MonoGenericSharingContext * D.33591;
  int D.33594;
  long unsigned int D.33597;
  long unsigned int D.33598;
  int D.33599;
  long unsigned int D.33602;
  long unsigned int D.33603;
  _Bool D.33607;
  long int D.33608;
  long int D.33609;
  int D.33612;
  int D.33613;
  int D.33614;
  int D.33615;
  int D.33616;
  int D.33617;
  int D.33618;
  int D.33619;
  int D.33620;
  int D.33621;
  int D.33622;
  int D.33623;
  int D.33624;
  int D.33625;
  int D.33626;
  int D.33627;
  int D.33628;
  int D.33629;
  int D.33630;
  int D.33631;
  int D.33632;
  int D.33633;
  int D.33634;
  int D.33635;
  int D.33636;
  int D.33637;
  int D.33638;
  int D.33639;
  int D.33640;
  void * D.33641;
  struct GHashTable * D.33642;
  void * D.33647;
  _Bool D.33650;
  long int D.33651;
  long int D.33652;
  _Bool D.33657;
  long int D.33658;
  long int D.33659;
  unsigned int D.33662;
  struct MonoMethod * D.33667;
  struct MonoMethod * D.33670;
  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.33249 = opt & 65536;
  if (D.33249 != 0) goto <D.33250>; else goto <D.33251>;
  <D.33250>:
  {
    struct MonoDomain * domain;

    domain = mono_domain_get ();
    method.170 = method;
    D.33253 = method.170->klass;
    mono_class_init (D.33253);
    method.170 = method;
    code = mono_aot_get_method (domain, method.170);
    if (code != 0B) goto <D.33254>; else goto <D.33255>;
    <D.33254>:
    method.170 = method;
    D.33253 = method.170->klass;
    vtable = mono_class_vtable (domain, D.33253);
    D.33256 = vtable == 0B;
    D.33257 = (long int) D.33256;
    D.33258 = __builtin_expect (D.33257, 0);
    if (D.33258 != 0) goto <D.33259>; else goto <D.33260>;
    <D.33259>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5817, "vtable");
    <D.33260>:
    mono_runtime_class_init (vtable);
    D.33261 = code;
    return D.33261;
    <D.33255>:
  }
  <D.33251>:
  method.170 = method;
  D.33264 = method.170->iflags;
  D.33265 = (int) D.33264;
  D.33266 = D.33265 & 4096;
  if (D.33266 != 0) goto <D.33262>; else goto <D.33267>;
  <D.33267>:
  method.170 = method;
  D.33268 = method.170->flags;
  D.33269 = (int) D.33268;
  D.33270 = D.33269 & 8192;
  if (D.33270 != 0) goto <D.33262>; else goto <D.33263>;
  <D.33262>:
  {
    struct MonoMethod * nm;
    struct MonoMethodPInvoke * piinfo;

    piinfo = method;
    D.33271 = piinfo->addr;
    if (D.33271 == 0B) goto <D.33272>; else goto <D.33273>;
    <D.33272>:
    method.170 = method;
    D.33264 = method.170->iflags;
    D.33265 = (int) D.33264;
    D.33266 = D.33265 & 4096;
    if (D.33266 != 0) goto <D.33274>; else goto <D.33275>;
    <D.33274>:
    method.170 = method;
    D.33276 = mono_lookup_internal_call (method.170);
    piinfo->addr = D.33276;
    goto <D.33277>;
    <D.33275>:
    method.170 = method;
    D.33264 = method.170->iflags;
    D.33265 = (int) D.33264;
    D.33278 = D.33265 & 1;
    if (D.33278 != 0) goto <D.33279>; else goto <D.33280>;
    <D.33279>:
    method.170 = method;
    D.33281 = mono_method_full_name (method.170, 1);
    method.170 = method;
    D.33253 = method.170->klass;
    D.33282 = D.33253->image;
    D.33283 = D.33282->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.33281, D.33283);
    goto <D.33284>;
    <D.33280>:
    method.170 = method;
    mono_lookup_pinvoke_call (method.170, 0B, 0B);
    <D.33284>:
    <D.33277>:
    <D.33273>:
    method.170 = method;
    check_for_pending_exc.171 = check_for_pending_exc;
    nm = mono_marshal_get_native_wrapper (method.170, check_for_pending_exc.171, 0);
    D.33286 = mono_compile_method (nm);
    code = mono_get_addr_from_ftnptr (D.33286);
    jinfo = mono_jit_info_table_find (target_domain, code);
    if (jinfo == 0B) goto <D.33287>; else goto <D.33288>;
    <D.33287>:
    D.33289 = mono_domain_get ();
    jinfo = mono_jit_info_table_find (D.33289, code);
    <D.33288>:
    if (jinfo != 0B) goto <D.33290>; else goto <D.33291>;
    <D.33290>:
    method.170 = method;
    mono_profiler_method_end_jit (method.170, jinfo, 0);
    <D.33291>:
    D.33261 = code;
    return D.33261;
  }
  <D.33263>:
  method.170 = method;
  D.33264 = method.170->iflags;
  D.33265 = (int) D.33264;
  D.33292 = D.33265 & 3;
  if (D.33292 != 0) goto <D.33293>; else goto <D.33294>;
  <D.33293>:
  {
    const char * name;
    char * full_name;
    char * msg;
    struct MonoMethod * nm;

    method.170 = method;
    name = method.170->name;
    method.170 = method;
    D.33253 = method.170->klass;
    D.33295 = D.33253->parent;
    D.33296 = mono_defaults.multicastdelegate_class;
    if (D.33295 == D.33296) goto <D.33297>; else goto <D.33298>;
    <D.33297>:
    D.33300 = *name;
    if (D.33300 == 46) goto <D.33301>; else goto <D.33299>;
    <D.33301>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.33305 = ".ctor";
        D.33306 = MEM[(const unsigned char *)D.33305];
        D.33307 = (int) D.33306;
        D.33308 = *__s2;
        D.33309 = (int) D.33308;
        __result = D.33307 - D.33309;
        {
          D.33310 = __s2_len != 0;
          D.33311 = __result == 0;
          D.33312 = D.33310 & D.33311;
          if (D.33312 != 0) goto <D.33313>; else goto <D.33314>;
          <D.33313>:
          D.33315 = &MEM[(void *)".ctor" + 1B];
          D.33316 = *D.33315;
          D.33317 = (int) D.33316;
          D.33318 = __s2 + 1;
          D.33319 = *D.33318;
          D.33320 = (int) D.33319;
          __result = D.33317 - D.33320;
          D.33321 = __s2_len > 1;
          D.33311 = __result == 0;
          D.33322 = D.33321 & D.33311;
          if (D.33322 != 0) goto <D.33323>; else goto <D.33324>;
          <D.33323>:
          D.33325 = &MEM[(void *)".ctor" + 2B];
          D.33326 = *D.33325;
          D.33327 = (int) D.33326;
          D.33328 = __s2 + 2;
          D.33329 = *D.33328;
          D.33330 = (int) D.33329;
          __result = D.33327 - D.33330;
          D.33331 = __s2_len > 2;
          D.33311 = __result == 0;
          D.33332 = D.33331 & D.33311;
          if (D.33332 != 0) goto <D.33333>; else goto <D.33334>;
          <D.33333>:
          D.33335 = &MEM[(void *)".ctor" + 3B];
          D.33336 = *D.33335;
          D.33337 = (int) D.33336;
          D.33338 = __s2 + 3;
          D.33339 = *D.33338;
          D.33340 = (int) D.33339;
          __result = D.33337 - D.33340;
          <D.33334>:
          <D.33324>:
          <D.33314>:
        }
        D.28789 = __result;
      }
      iftmp.172 = -D.28789;
      goto <D.33341>;
      <D.33304>:
      iftmp.172 = __builtin_strcmp (name, ".ctor");
      <D.33341>:
      D.28790 = iftmp.172;
    }
    if (D.28790 == 0) goto <D.33342>; else goto <D.33299>;
    <D.33342>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
      D.33343 = mi == 0B;
      D.33344 = (long int) D.33343;
      D.33345 = __builtin_expect (D.33344, 0);
      if (D.33345 != 0) goto <D.33346>; else goto <D.33347>;
      <D.33346>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 5858, "mi");
      <D.33347>:
      D.33348 = mono_icall_get_wrapper_full (mi, 1);
      D.33261 = mono_get_addr_from_ftnptr (D.33348);
      return D.33261;
    }
    <D.33299>:
    D.33300 = *name;
    if (D.33300 == 73) goto <D.33350>; else goto <D.33349>;
    <D.33350>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.33354 = "Invoke";
        D.33355 = MEM[(const unsigned char *)D.33354];
        D.33356 = (int) D.33355;
        D.33357 = *__s2;
        D.33358 = (int) D.33357;
        __result = D.33356 - D.33358;
        {
          D.33359 = __s2_len != 0;
          D.33360 = __result == 0;
          D.33361 = D.33359 & D.33360;
          if (D.33361 != 0) goto <D.33362>; else goto <D.33363>;
          <D.33362>:
          D.33364 = &MEM[(void *)"Invoke" + 1B];
          D.33365 = *D.33364;
          D.33366 = (int) D.33365;
          D.33367 = __s2 + 1;
          D.33368 = *D.33367;
          D.33369 = (int) D.33368;
          __result = D.33366 - D.33369;
          D.33370 = __s2_len > 1;
          D.33360 = __result == 0;
          D.33371 = D.33370 & D.33360;
          if (D.33371 != 0) goto <D.33372>; else goto <D.33373>;
          <D.33372>:
          D.33374 = &MEM[(void *)"Invoke" + 2B];
          D.33375 = *D.33374;
          D.33376 = (int) D.33375;
          D.33377 = __s2 + 2;
          D.33378 = *D.33377;
          D.33379 = (int) D.33378;
          __result = D.33376 - D.33379;
          D.33380 = __s2_len > 2;
          D.33360 = __result == 0;
          D.33381 = D.33380 & D.33360;
          if (D.33381 != 0) goto <D.33382>; else goto <D.33383>;
          <D.33382>:
          D.33384 = &MEM[(void *)"Invoke" + 3B];
          D.33385 = *D.33384;
          D.33386 = (int) D.33385;
          D.33387 = __s2 + 3;
          D.33388 = *D.33387;
          D.33389 = (int) D.33388;
          __result = D.33386 - D.33389;
          <D.33383>:
          <D.33373>:
          <D.33363>:
        }
        D.28799 = __result;
      }
      iftmp.173 = -D.28799;
      goto <D.33390>;
      <D.33353>:
      iftmp.173 = __builtin_strcmp (name, "Invoke");
      <D.33390>:
      D.28800 = iftmp.173;
    }
    if (D.28800 == 0) goto <D.33391>; else goto <D.33349>;
    <D.33391>:
    method.170 = method;
    D.33253 = method.170->klass;
    D.33261 = mono_create_delegate_trampoline (target_domain, D.33253);
    return D.33261;
    <D.33349>:
    D.33300 = *name;
    if (D.33300 == 66) goto <D.33393>; else goto <D.33392>;
    <D.33393>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.33397 = "BeginInvoke";
        D.33398 = MEM[(const unsigned char *)D.33397];
        D.33399 = (int) D.33398;
        D.33400 = *__s2;
        D.33401 = (int) D.33400;
        __result = D.33399 - D.33401;
        {
          D.33402 = __s2_len != 0;
          D.33403 = __result == 0;
          D.33404 = D.33402 & D.33403;
          if (D.33404 != 0) goto <D.33405>; else goto <D.33406>;
          <D.33405>:
          D.33407 = &MEM[(void *)"BeginInvoke" + 1B];
          D.33408 = *D.33407;
          D.33409 = (int) D.33408;
          D.33410 = __s2 + 1;
          D.33411 = *D.33410;
          D.33412 = (int) D.33411;
          __result = D.33409 - D.33412;
          D.33413 = __s2_len > 1;
          D.33403 = __result == 0;
          D.33414 = D.33413 & D.33403;
          if (D.33414 != 0) goto <D.33415>; else goto <D.33416>;
          <D.33415>:
          D.33417 = &MEM[(void *)"BeginInvoke" + 2B];
          D.33418 = *D.33417;
          D.33419 = (int) D.33418;
          D.33420 = __s2 + 2;
          D.33421 = *D.33420;
          D.33422 = (int) D.33421;
          __result = D.33419 - D.33422;
          D.33423 = __s2_len > 2;
          D.33403 = __result == 0;
          D.33424 = D.33423 & D.33403;
          if (D.33424 != 0) goto <D.33425>; else goto <D.33426>;
          <D.33425>:
          D.33427 = &MEM[(void *)"BeginInvoke" + 3B];
          D.33428 = *D.33427;
          D.33429 = (int) D.33428;
          D.33430 = __s2 + 3;
          D.33431 = *D.33430;
          D.33432 = (int) D.33431;
          __result = D.33429 - D.33432;
          <D.33426>:
          <D.33416>:
          <D.33406>:
        }
        D.28808 = __result;
      }
      iftmp.174 = -D.28808;
      goto <D.33433>;
      <D.33396>:
      iftmp.174 = __builtin_strcmp (name, "BeginInvoke");
      <D.33433>:
      D.28809 = iftmp.174;
    }
    if (D.28809 == 0) goto <D.33434>; else goto <D.33392>;
    <D.33434>:
    method.170 = method;
    nm = mono_marshal_get_delegate_begin_invoke (method.170);
    D.33435 = mono_compile_method (nm);
    D.33261 = mono_get_addr_from_ftnptr (D.33435);
    return D.33261;
    <D.33392>:
    D.33300 = *name;
    if (D.33300 == 69) goto <D.33436>; else goto <D.33437>;
    <D.33436>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.33441 = "EndInvoke";
        D.33442 = MEM[(const unsigned char *)D.33441];
        D.33443 = (int) D.33442;
        D.33444 = *__s2;
        D.33445 = (int) D.33444;
        __result = D.33443 - D.33445;
        {
          D.33446 = __s2_len != 0;
          D.33447 = __result == 0;
          D.33448 = D.33446 & D.33447;
          if (D.33448 != 0) goto <D.33449>; else goto <D.33450>;
          <D.33449>:
          D.33451 = &MEM[(void *)"EndInvoke" + 1B];
          D.33452 = *D.33451;
          D.33453 = (int) D.33452;
          D.33454 = __s2 + 1;
          D.33455 = *D.33454;
          D.33456 = (int) D.33455;
          __result = D.33453 - D.33456;
          D.33457 = __s2_len > 1;
          D.33447 = __result == 0;
          D.33458 = D.33457 & D.33447;
          if (D.33458 != 0) goto <D.33459>; else goto <D.33460>;
          <D.33459>:
          D.33461 = &MEM[(void *)"EndInvoke" + 2B];
          D.33462 = *D.33461;
          D.33463 = (int) D.33462;
          D.33464 = __s2 + 2;
          D.33465 = *D.33464;
          D.33466 = (int) D.33465;
          __result = D.33463 - D.33466;
          D.33467 = __s2_len > 2;
          D.33447 = __result == 0;
          D.33468 = D.33467 & D.33447;
          if (D.33468 != 0) goto <D.33469>; else goto <D.33470>;
          <D.33469>:
          D.33471 = &MEM[(void *)"EndInvoke" + 3B];
          D.33472 = *D.33471;
          D.33473 = (int) D.33472;
          D.33474 = __s2 + 3;
          D.33475 = *D.33474;
          D.33476 = (int) D.33475;
          __result = D.33473 - D.33476;
          <D.33470>:
          <D.33460>:
          <D.33450>:
        }
        D.28817 = __result;
      }
      iftmp.175 = -D.28817;
      goto <D.33477>;
      <D.33440>:
      iftmp.175 = __builtin_strcmp (name, "EndInvoke");
      <D.33477>:
      D.28818 = iftmp.175;
    }
    if (D.28818 == 0) goto <D.33478>; else goto <D.33479>;
    <D.33478>:
    method.170 = method;
    nm = mono_marshal_get_delegate_end_invoke (method.170);
    D.33480 = mono_compile_method (nm);
    D.33261 = mono_get_addr_from_ftnptr (D.33480);
    return D.33261;
    <D.33479>:
    <D.33437>:
    <D.33298>:
    method.170 = method;
    full_name = mono_method_full_name (method.170, 1);
    msg = monoeg_g_strdup_printf ("Unrecognizable runtime implemented method \'%s\'", full_name);
    D.33481 = mono_defaults.corlib;
    D.33482 = mono_exception_from_name_msg (D.33481, "System", "InvalidProgramException", msg);
    *jit_ex = D.33482;
    monoeg_g_free (full_name);
    monoeg_g_free (msg);
    D.33261 = 0B;
    return D.33261;
  }
  <D.33294>:
  method.170 = method;
  D.33483 = BIT_FIELD_REF <*method.170, 8, 160>;
  D.33484 = D.33483 & 124;
  if (D.33484 == 100) goto <D.33485>; else goto <D.33486>;
  <D.33485>:
  {
    struct WrapperInfo * info;

    method.170 = method;
    info = mono_marshal_get_wrapper_info (method.170);
    D.33487 = info->subtype;
    D.33488 = D.33487 + 4294967278;
    if (D.33488 <= 1) goto <D.33489>; else goto <D.33490>;
    <D.33489>:
    {
      static struct MonoTrampInfo * in_tinfo;
      static struct MonoTrampInfo * out_tinfo;
      struct MonoTrampInfo * tinfo;
      struct MonoJitInfo * jinfo;
      gboolean is_in;

      try
        {
          D.33487 = info->subtype;
          D.33491 = D.33487 == 18;
          is_in = (gboolean) D.33491;
          if (is_in != 0) goto <D.33493>; else goto <D.33492>;
          <D.33493>:
          in_tinfo.176 = in_tinfo;
          if (in_tinfo.176 != 0B) goto <D.33495>; else goto <D.33492>;
          <D.33495>:
          in_tinfo.176 = in_tinfo;
          D.33261 = in_tinfo.176->code;
          return D.33261;
          <D.33492>:
          if (is_in == 0) goto <D.33496>; else goto <D.33497>;
          <D.33496>:
          out_tinfo.177 = out_tinfo;
          if (out_tinfo.177 != 0B) goto <D.33499>; else goto <D.33500>;
          <D.33499>:
          out_tinfo.177 = out_tinfo;
          D.33261 = out_tinfo.177->code;
          return D.33261;
          <D.33500>:
          <D.33497>:
          mono_aot_only.178 = mono_aot_only;
          if (mono_aot_only.178 != 0) goto <D.33502>; else goto <D.33503>;
          <D.33502>:
          if (is_in != 0) goto <D.33505>; else goto <D.33506>;
          <D.33505>:
          iftmp.179 = "gsharedvt_trampoline";
          goto <D.33507>;
          <D.33506>:
          iftmp.179 = "gsharedvt_out_trampoline";
          <D.33507>:
          mono_aot_get_trampoline_full (iftmp.179, &tinfo);
          goto <D.33508>;
          <D.33503>:
          mono_arch_get_gsharedvt_trampoline (&tinfo, 0);
          <D.33508>:
          method.170 = method;
          tinfo.180 = tinfo;
          jinfo = create_jit_info_for_trampoline (method.170, tinfo.180);
          D.33510 = mono_get_root_domain ();
          mono_jit_info_table_add (D.33510, jinfo);
          if (is_in != 0) goto <D.33511>; else goto <D.33512>;
          <D.33511>:
          tinfo.180 = tinfo;
          in_tinfo = tinfo.180;
          goto <D.33513>;
          <D.33512>:
          tinfo.180 = tinfo;
          out_tinfo = tinfo.180;
          <D.33513>:
          tinfo.180 = tinfo;
          D.33261 = tinfo.180->code;
          return D.33261;
        }
      finally
        {
          tinfo = {CLOBBER};
        }
    }
    <D.33490>:
  }
  <D.33486>:
  mono_aot_only.178 = mono_aot_only;
  if (mono_aot_only.178 != 0) goto <D.33514>; else goto <D.33515>;
  <D.33514>:
  {
    char * fullname;
    char * msg;

    method.170 = method;
    fullname = mono_method_full_name (method.170, 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.33516 = mono_get_exception_execution_engine (msg);
    *jit_ex = D.33516;
    monoeg_g_free (fullname);
    monoeg_g_free (msg);
    D.33261 = 0B;
    return D.33261;
  }
  <D.33515>:
  jit_timer = monoeg_g_timer_new ();
  method.170 = method;
  opt.181 = (unsigned int) opt;
  cfg = mini_method_compile (method.170, opt.181, target_domain, 1, 0);
  prof_method = cfg->method;
  monoeg_g_timer_stop (jit_timer);
  D.33518 = monoeg_g_timer_elapsed (jit_timer, 0B);
  D.33519 = mono_jit_stats.jit_time;
  D.33520 = D.33519 + D.33518;
  mono_jit_stats.jit_time = D.33520;
  monoeg_g_timer_destroy (jit_timer);
  D.33521 = cfg->exception_type;
  switch (D.33521) <default: <D.28846>, case 0: <D.28827>, case 1: <D.28839>, case 3: <D.28835>, case 4: <D.28836>, case 5: <D.28831>, case 6: <D.28830>, case 7: <D.28829>, case 8: <D.28832>, case 9: <D.28837>, case 10: <D.28838>, case 12: <D.28833>, case 13: <D.28843>, case 14: <D.28845>>
  <D.28827>:
  goto <D.28828>;
  <D.28829>:
  <D.28830>:
  <D.28831>:
  <D.28832>:
  <D.28833>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.33522>; else goto <D.33523>;
    <D.33522>:
    ex = mono_loader_error_prepare_exception (error);
    goto <D.33524>;
    <D.33523>:
    D.33525 = cfg->exception_ptr;
    if (D.33525 != 0B) goto <D.33526>; else goto <D.33527>;
    <D.33526>:
    D.33525 = cfg->exception_ptr;
    ex = mono_class_get_exception_for_failure (D.33525);
    goto <D.33528>;
    <D.33527>:
    D.33521 = cfg->exception_type;
    if (D.33521 == 6) goto <D.33529>; else goto <D.33530>;
    <D.33529>:
    D.33481 = mono_defaults.corlib;
    D.33531 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.33481, "System", "MissingFieldException", D.33531);
    goto <D.33532>;
    <D.33530>:
    D.33521 = cfg->exception_type;
    if (D.33521 == 5) goto <D.33533>; else goto <D.33534>;
    <D.33533>:
    D.33481 = mono_defaults.corlib;
    D.33531 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.33481, "System", "MissingMethodException", D.33531);
    goto <D.33535>;
    <D.33534>:
    D.33521 = cfg->exception_type;
    if (D.33521 == 7) goto <D.33536>; else goto <D.33537>;
    <D.33536>:
    D.33481 = mono_defaults.corlib;
    D.33531 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.33481, "System", "TypeLoadException", D.33531);
    goto <D.33538>;
    <D.33537>:
    D.33521 = cfg->exception_type;
    if (D.33521 == 8) goto <D.33539>; else goto <D.33540>;
    <D.33539>:
    D.33481 = mono_defaults.corlib;
    D.33531 = cfg->exception_message;
    ex = mono_exception_from_name_msg (D.33481, "System", "FileNotFoundException", D.33531);
    goto <D.33541>;
    <D.33540>:
    D.33521 = cfg->exception_type;
    if (D.33521 == 12) goto <D.33542>; else goto <D.33543>;
    <D.33542>:
    D.33531 = cfg->exception_message;
    ex = mono_get_exception_bad_image_format (D.33531);
    goto <D.33544>;
    <D.33543>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 5975);
    <D.33544>:
    <D.33541>:
    <D.33538>:
    <D.33535>:
    <D.33532>:
    <D.33528>:
    <D.33524>:
    goto <D.28828>;
  }
  <D.28835>:
  D.33481 = mono_defaults.corlib;
  D.33531 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.33481, "System", "InvalidProgramException", D.33531);
  goto <D.28828>;
  <D.28836>:
  D.33481 = mono_defaults.corlib;
  D.33531 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.33481, "System.Security", "VerificationException", D.33531);
  goto <D.28828>;
  <D.28837>:
  D.33481 = mono_defaults.corlib;
  D.33531 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.33481, "System", "MethodAccessException", D.33531);
  goto <D.28828>;
  <D.28838>:
  D.33481 = mono_defaults.corlib;
  D.33531 = cfg->exception_message;
  ex = mono_exception_from_name_msg (D.33481, "System", "FieldAccessException", D.33531);
  goto <D.28828>;
  <D.28839>:
  {
    struct MonoSecurityManager * secman;
    struct MonoObject * exc;
    void * args[2];

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

    exp = cfg->exception_ptr;
    D.33547 = &cfg->exception_ptr;
    mono_gc_deregister_root (D.33547);
    ex = exp;
    goto <D.28828>;
  }
  <D.28845>:
  D.33548 = mono_domain_get ();
  ex = D.33548->out_of_memory_ex;
  goto <D.28828>;
  <D.28846>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6018);
  <D.28828>:
  if (ex != 0B) goto <D.33549>; else goto <D.33550>;
  <D.33549>:
  D.33551 = cfg->prof_options;
  D.33552 = D.33551 & 16;
  if (D.33552 != 0) goto <D.33553>; else goto <D.33554>;
  <D.33553>:
  method.170 = method;
  mono_profiler_method_end_jit (method.170, 0B, 1);
  <D.33554>:
  mono_destroy_compile (cfg);
  *jit_ex = ex;
  D.33261 = 0B;
  return D.33261;
  <D.33550>:
  mono_loader_lock ();
  {
    int ret;

    D.33555 = &target_domain->lock.mutex;
    ret = pthread_mutex_lock (D.33555);
    if (ret != 0) goto <D.33556>; else goto <D.33557>;
    <D.33556>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33557>:
    D.33558 = ret != 0;
    D.33559 = (long int) D.33558;
    D.33560 = __builtin_expect (D.33559, 0);
    if (D.33560 != 0) goto <D.33561>; else goto <D.33562>;
    <D.33561>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6032, "ret == 0");
    <D.33562>:
  }
  {
    int ret;

    D.33563 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_lock (D.33563);
    if (ret != 0) goto <D.33564>; else goto <D.33565>;
    <D.33564>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33565>:
    D.33566 = ret != 0;
    D.33567 = (long int) D.33566;
    D.33568 = __builtin_expect (D.33567, 0);
    if (D.33568 != 0) goto <D.33569>; else goto <D.33570>;
    <D.33569>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6037, "ret == 0");
    <D.33570>:
  }
  method.170 = method;
  info = lookup_method_inner (target_domain, method.170);
  if (info != 0B) goto <D.33571>; else goto <D.33572>;
  <D.33571>:
  D.33575 = mono_domain_get ();
  if (D.33575 == target_domain) goto <D.33573>; else goto <D.33576>;
  <D.33576>:
  D.33577 = BIT_FIELD_REF <*info, 8, 168>;
  D.33578 = D.33577 & 128;
  if (D.33578 != 0) goto <D.33573>; else goto <D.33574>;
  <D.33573>:
  code = info->code_start;
  <D.33574>:
  <D.33572>:
  if (code == 0B) goto <D.33579>; else goto <D.33580>;
  <D.33579>:
  D.33581 = &target_domain->jit_code_hash;
  D.33582 = cfg->jit_info;
  D.33583 = D.33582->d.method;
  D.33582 = cfg->jit_info;
  mono_internal_hash_table_insert (D.33581, D.33583, D.33582);
  {
    int ret;

    D.33563 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.33563);
    if (ret != 0) goto <D.33584>; else goto <D.33585>;
    <D.33584>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33585>:
    D.33586 = ret != 0;
    D.33587 = (long int) D.33586;
    D.33588 = __builtin_expect (D.33587, 0);
    if (D.33588 != 0) goto <D.33589>; else goto <D.33590>;
    <D.33589>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6050, "ret == 0");
    <D.33590>:
  }
  code = cfg->native_code;
  D.33591 = cfg->generic_sharing_context;
  if (D.33591 != 0B) goto <D.33592>; else goto <D.33593>;
  <D.33592>:
  method.170 = method;
  D.33594 = mono_method_is_generic_sharable (method.170, 0);
  if (D.33594 != 0) goto <D.33595>; else goto <D.33596>;
  <D.33595>:
  D.33597 = mono_stats.generics_shared_methods;
  D.33598 = D.33597 + 1;
  mono_stats.generics_shared_methods = D.33598;
  <D.33596>:
  <D.33593>:
  D.33599 = cfg->gsharedvt;
  if (D.33599 != 0) goto <D.33600>; else goto <D.33601>;
  <D.33600>:
  D.33602 = mono_stats.gsharedvt_methods;
  D.33603 = D.33602 + 1;
  mono_stats.gsharedvt_methods = D.33603;
  <D.33601>:
  goto <D.33604>;
  <D.33580>:
  {
    int ret;

    D.33563 = &target_domain->jit_code_hash_lock.mutex;
    ret = pthread_mutex_unlock (D.33563);
    if (ret != 0) goto <D.33605>; else goto <D.33606>;
    <D.33605>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33606>:
    D.33607 = ret != 0;
    D.33608 = (long int) D.33607;
    D.33609 = __builtin_expect (D.33608, 0);
    if (D.33609 != 0) goto <D.33610>; else goto <D.33611>;
    <D.33610>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6058, "ret == 0");
    <D.33611>:
  }
  <D.33604>:
  jinfo = cfg->jit_info;
  prof_options = cfg->prof_options;
  D.33612 = mono_jit_stats.allocate_var;
  D.33613 = cfg->stat_allocate_var;
  D.33614 = D.33612 + D.33613;
  mono_jit_stats.allocate_var = D.33614;
  D.33615 = mono_jit_stats.locals_stack_size;
  D.33616 = cfg->stat_locals_stack_size;
  D.33617 = D.33615 + D.33616;
  mono_jit_stats.locals_stack_size = D.33617;
  D.33618 = mono_jit_stats.basic_blocks;
  D.33619 = cfg->stat_basic_blocks;
  D.33620 = D.33618 + D.33619;
  mono_jit_stats.basic_blocks = D.33620;
  D.33621 = mono_jit_stats.max_basic_blocks;
  D.33619 = cfg->stat_basic_blocks;
  D.33622 = MAX_EXPR <D.33621, D.33619>;
  mono_jit_stats.max_basic_blocks = D.33622;
  D.33623 = mono_jit_stats.cil_code_size;
  D.33624 = cfg->stat_cil_code_size;
  D.33625 = D.33623 + D.33624;
  mono_jit_stats.cil_code_size = D.33625;
  D.33626 = mono_jit_stats.regvars;
  D.33627 = cfg->stat_n_regvars;
  D.33628 = D.33626 + D.33627;
  mono_jit_stats.regvars = D.33628;
  D.33629 = mono_jit_stats.inlineable_methods;
  D.33630 = cfg->stat_inlineable_methods;
  D.33631 = D.33629 + D.33630;
  mono_jit_stats.inlineable_methods = D.33631;
  D.33632 = mono_jit_stats.inlined_methods;
  D.33633 = cfg->stat_inlined_methods;
  D.33634 = D.33632 + D.33633;
  mono_jit_stats.inlined_methods = D.33634;
  D.33635 = mono_jit_stats.cas_demand_generation;
  D.33636 = cfg->stat_cas_demand_generation;
  D.33637 = D.33635 + D.33636;
  mono_jit_stats.cas_demand_generation = D.33637;
  D.33638 = mono_jit_stats.code_reallocs;
  D.33639 = cfg->stat_code_reallocs;
  D.33640 = D.33638 + D.33639;
  mono_jit_stats.code_reallocs = D.33640;
  mono_destroy_compile (cfg);
  D.33641 = target_domain->runtime_info;
  D.33642 = MEM[(struct MonoJitDomainInfo *)D.33641].jump_target_hash;
  if (D.33642 != 0B) goto <D.33643>; else goto <D.33644>;
  <D.33643>:
  {
    struct MonoJumpInfo patch_info;
    struct MonoJumpList * jlist;
    struct GSList * tmp;

    try
      {
        D.33641 = target_domain->runtime_info;
        D.33642 = MEM[(struct MonoJitDomainInfo *)D.33641].jump_target_hash;
        method.170 = method;
        jlist = monoeg_g_hash_table_lookup (D.33642, method.170);
        if (jlist != 0B) goto <D.33645>; else goto <D.33646>;
        <D.33645>:
        patch_info.next = 0B;
        patch_info.ip.i = 0;
        patch_info.type = 4;
        method.170 = method;
        patch_info.data.method = method.170;
        D.33641 = target_domain->runtime_info;
        D.33642 = MEM[(struct MonoJitDomainInfo *)D.33641].jump_target_hash;
        method.170 = method;
        monoeg_g_hash_table_remove (D.33642, method.170);
        tmp = jlist->list;
        goto <D.28855>;
        <D.28854>:
        D.33647 = tmp->data;
        mono_arch_patch_code (0B, target_domain, D.33647, &patch_info, 0B, 1);
        tmp = tmp->next;
        <D.28855>:
        if (tmp != 0B) goto <D.28854>; else goto <D.28856>;
        <D.28856>:
        <D.33646>:
      }
    finally
      {
        patch_info = {CLOBBER};
      }
  }
  <D.33644>:
  mono_emit_jit_map (jinfo);
  {
    int ret;

    D.33555 = &target_domain->lock.mutex;
    ret = pthread_mutex_unlock (D.33555);
    if (ret != 0) goto <D.33648>; else goto <D.33649>;
    <D.33648>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33649>:
    D.33650 = ret != 0;
    D.33651 = (long int) D.33650;
    D.33652 = __builtin_expect (D.33651, 0);
    if (D.33652 != 0) goto <D.33653>; else goto <D.33654>;
    <D.33653>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6109, "ret == 0");
    <D.33654>:
  }
  mono_loader_unlock ();
  method.170 = method;
  D.33253 = method.170->klass;
  vtable = mono_class_vtable (target_domain, D.33253);
  if (vtable == 0B) goto <D.33655>; else goto <D.33656>;
  <D.33655>:
  method.170 = method;
  D.33253 = method.170->klass;
  ex = mono_class_get_exception_for_failure (D.33253);
  D.33657 = ex == 0B;
  D.33658 = (long int) D.33657;
  D.33659 = __builtin_expect (D.33658, 0);
  if (D.33659 != 0) goto <D.33660>; else goto <D.33661>;
  <D.33660>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6115, "ex");
  <D.33661>:
  *jit_ex = ex;
  D.33261 = 0B;
  return D.33261;
  <D.33656>:
  D.33662 = prof_options & 16;
  if (D.33662 != 0) goto <D.33663>; else goto <D.33664>;
  <D.33663>:
  method.170 = method;
  D.33483 = BIT_FIELD_REF <*method.170, 8, 160>;
  D.33484 = D.33483 & 124;
  if (D.33484 == 24) goto <D.33665>; else goto <D.33666>;
  <D.33665>:
  method.170 = method;
  D.33667 = mono_marshal_method_from_wrapper (method.170);
  if (D.33667 != 0B) goto <D.33668>; else goto <D.33669>;
  <D.33668>:
  method.170 = method;
  D.33670 = mono_marshal_method_from_wrapper (method.170);
  mono_profiler_method_end_jit (D.33670, jinfo, 0);
  <D.33669>:
  <D.33666>:
  method.170 = method;
  mono_profiler_method_end_jit (method.170, jinfo, 0);
  method.170 = method;
  if (prof_method != method.170) goto <D.33671>; else goto <D.33672>;
  <D.33671>:
  mono_profiler_method_end_jit (prof_method, jinfo, 0);
  <D.33672>:
  <D.33664>:
  ex = mono_runtime_class_init_full (vtable, 0);
  if (ex != 0B) goto <D.33673>; else goto <D.33674>;
  <D.33673>:
  *jit_ex = ex;
  D.33261 = 0B;
  return D.33261;
  <D.33674>:
  D.33261 = code;
  return D.33261;
}


create_jit_info_for_trampoline (struct MonoMethod * wrapper, struct MonoTrampInfo * info)
{
  guint8 * D.33679;
  unsigned int info_len.182;
  struct GSList * D.33684;
  guint8 * D.33685;
  unsigned int D.33686;
  int D.33687;
  unsigned int info_len.183;
  unsigned int D.33689;
  struct MonoJitInfo * D.33690;
  struct MonoDomain * domain;
  struct MonoJitInfo * jinfo;
  guint8 * uw_info;
  guint32 info_len;

  try
    {
      domain = mono_get_root_domain ();
      D.33679 = info->uw_info;
      if (D.33679 != 0B) goto <D.33680>; else goto <D.33681>;
      <D.33680>:
      uw_info = info->uw_info;
      info_len.182 = info->uw_info_len;
      info_len = info_len.182;
      goto <D.33683>;
      <D.33681>:
      D.33684 = info->unwind_ops;
      uw_info = mono_unwind_ops_encode (D.33684, &info_len);
      <D.33683>:
      jinfo = mono_domain_alloc0 (domain, 28);
      jinfo->d.method = wrapper;
      D.33685 = info->code;
      jinfo->code_start = D.33685;
      D.33686 = info->code_size;
      D.33687 = (int) D.33686;
      jinfo->code_size = D.33687;
      info_len.183 = info_len;
      D.33689 = mono_cache_unwind_info (uw_info, info_len.183);
      jinfo->used_regs = D.33689;
      D.33690 = jinfo;
      return D.33690;
    }
  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.184;
  unsigned int D.33694;
  unsigned char D.33703;
  unsigned char D.33704;
  int D.33705;
  int D.33706;
  void * D.33709;
  struct MonoDomain * target_domain;
  struct MonoJitInfo * info;

  default_opt.184 = default_opt;
  D.33694 = default_opt.184 & 512;
  if (D.33694 != 0) goto <D.33695>; else goto <D.33696>;
  <D.33695>:
  target_domain = mono_get_root_domain ();
  goto <D.33697>;
  <D.33696>:
  target_domain = domain;
  <D.33697>:
  info = lookup_method (target_domain, method);
  if (info != 0B) goto <D.33698>; else goto <D.33699>;
  <D.33698>:
  if (domain == target_domain) goto <D.33700>; else goto <D.33702>;
  <D.33702>:
  D.33703 = BIT_FIELD_REF <*info, 8, 168>;
  D.33704 = D.33703 & 128;
  if (D.33704 != 0) goto <D.33700>; else goto <D.33701>;
  <D.33700>:
  D.33705 = mono_jit_stats.methods_lookups;
  D.33706 = D.33705 + 1;
  mono_jit_stats.methods_lookups = D.33706;
  if (ji != 0B) goto <D.33707>; else goto <D.33708>;
  <D.33707>:
  *ji = info;
  <D.33708>:
  D.33709 = info->code_start;
  return D.33709;
  <D.33701>:
  <D.33699>:
  if (ji != 0B) goto <D.33710>; else goto <D.33711>;
  <D.33710>:
  *ji = 0B;
  <D.33711>:
  D.33709 = 0B;
  return D.33709;
}


mono_get_optimizations_for_method (struct MonoMethod * method, guint32 default_opt)
{
  _Bool D.33713;
  long int D.33714;
  long int D.33715;
  int mono_do_single_method_regression.185;
  guint32 D.33721;
  struct MonoMethod * mono_current_single_method.186;
  struct GHashTable * mono_single_method_hash.187;
  struct GHashTable * mono_single_method_hash.188;
  void * D.33729;
  struct GSList * mono_single_method_list.189;
  struct GSList * mono_single_method_list.190;

  D.33713 = method == 0B;
  D.33714 = (long int) D.33713;
  D.33715 = __builtin_expect (D.33714, 0);
  if (D.33715 != 0) goto <D.33716>; else goto <D.33717>;
  <D.33716>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6380, "method");
  <D.33717>:
  mono_do_single_method_regression.185 = mono_do_single_method_regression;
  if (mono_do_single_method_regression.185 == 0) goto <D.33719>; else goto <D.33720>;
  <D.33719>:
  D.33721 = default_opt;
  return D.33721;
  <D.33720>:
  mono_current_single_method.186 = mono_current_single_method;
  if (mono_current_single_method.186 == 0B) goto <D.33723>; else goto <D.33724>;
  <D.33723>:
  mono_single_method_hash.187 = mono_single_method_hash;
  if (mono_single_method_hash.187 == 0B) goto <D.33726>; else goto <D.33727>;
  <D.33726>:
  mono_single_method_hash.188 = monoeg_g_hash_table_new (monoeg_g_direct_hash, monoeg_g_direct_equal);
  mono_single_method_hash = mono_single_method_hash.188;
  <D.33727>:
  mono_single_method_hash.187 = mono_single_method_hash;
  D.33729 = monoeg_g_hash_table_lookup (mono_single_method_hash.187, method);
  if (D.33729 == 0B) goto <D.33730>; else goto <D.33731>;
  <D.33730>:
  mono_single_method_hash.187 = mono_single_method_hash;
  monoeg_g_hash_table_insert_replace (mono_single_method_hash.187, method, method, 0);
  mono_single_method_list.189 = mono_single_method_list;
  mono_single_method_list.190 = monoeg_g_slist_prepend (mono_single_method_list.189, method);
  mono_single_method_list = mono_single_method_list.190;
  <D.33731>:
  D.33721 = default_opt;
  return D.33721;
  <D.33724>:
  mono_current_single_method.186 = mono_current_single_method;
  if (method == mono_current_single_method.186) goto <D.33734>; else goto <D.33735>;
  <D.33734>:
  D.33721 = mono_single_method_regression_opt;
  return D.33721;
  <D.33735>:
  D.33721 = default_opt;
  return D.33721;
}


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

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


mono_sigfpe_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoDomain * D.33739;
  void * D.33740;
  int D.33743;
  struct MonoException * exc;
  struct MonoJitInfo * ji;
  void * ctx;

  exc = 0B;
  ctx = context;
  D.33739 = mono_domain_get ();
  D.33740 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.33739, D.33740);
  exc = mono_get_exception_divide_by_zero ();
  if (ji == 0B) goto <D.33741>; else goto <D.33742>;
  <D.33741>:
  D.33743 = mono_chain_signal (_dummy, info, context);
  if (D.33743 != 0) goto <D.33744>; else goto <D.33745>;
  <D.33744>:
  return;
  <D.33745>:
  mono_handle_native_sigsegv (11, ctx);
  <D.33742>:
  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.191;
  int D.33748;
  int D.33751;
  void * D.33754;
  int D.33755;
  struct MonoDomain * D.33760;
  int D.33762;
  struct MonoDomain * D.33765;
  void * D.33766;
  int D.33769;
  struct MonoJitInfo * ji;
  struct MonoJitTlsData * jit_tls;
  void * fault_addr;
  void * ctx;

  mono_jit_tls_id.191 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.191);
  fault_addr = 0B;
  ctx = context;
  D.33748 = mono_arch_is_single_step_event (info, ctx);
  if (D.33748 != 0) goto <D.33749>; else goto <D.33750>;
  <D.33749>:
  mono_debugger_agent_single_step_event (ctx);
  return;
  <D.33750>:
  D.33751 = mono_arch_is_breakpoint_event (info, ctx);
  if (D.33751 != 0) goto <D.33752>; else goto <D.33753>;
  <D.33752>:
  mono_debugger_agent_breakpoint_hit (ctx);
  return;
  <D.33753>:
  fault_addr = info->_sifields._sigfault.si_addr;
  D.33754 = info->_sifields._sigfault.si_addr;
  D.33755 = mono_aot_is_pagefault (D.33754);
  if (D.33755 != 0) goto <D.33756>; else goto <D.33757>;
  <D.33756>:
  D.33754 = info->_sifields._sigfault.si_addr;
  mono_aot_handle_pagefault (D.33754);
  return;
  <D.33757>:
  D.33760 = mono_domain_get ();
  if (D.33760 == 0B) goto <D.33758>; else goto <D.33761>;
  <D.33761>:
  if (jit_tls == 0B) goto <D.33758>; else goto <D.33759>;
  <D.33758>:
  D.33762 = mono_chain_signal (_dummy, info, context);
  if (D.33762 != 0) goto <D.33763>; else goto <D.33764>;
  <D.33763>:
  return;
  <D.33764>:
  mono_handle_native_sigsegv (11, ctx);
  <D.33759>:
  D.33765 = mono_domain_get ();
  D.33766 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.33765, D.33766);
  if (ji == 0B) goto <D.33767>; else goto <D.33768>;
  <D.33767>:
  D.33769 = mono_chain_signal (_dummy, info, context);
  if (D.33769 != 0) goto <D.33770>; else goto <D.33771>;
  <D.33770>:
  return;
  <D.33771>:
  mono_handle_native_sigsegv (11, ctx);
  <D.33768>:
  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.33773;
  long int D.33774;
  long int D.33775;
  void * * vtable_trampolines.192;
  int D.33782;
  int vtable_trampolines_size.193;
  _Bool D.33786;
  long int D.33787;
  long int D.33788;
  int iftmp.194;
  unsigned int new_size.195;
  unsigned int D.33799;
  unsigned int vtable_trampolines_size.196;
  unsigned int D.33803;
  _Bool D.33806;
  long int D.33807;
  long int D.33808;
  unsigned int index.197;
  unsigned int D.33812;
  void * * D.33813;
  void * D.33814;
  void * slot_index.198;
  struct MonoDomain * D.33818;
  void * D.33819;
  void * D.33820;
  int index;

  index = slot_index + 19;
  D.33773 = slot_index < -19;
  D.33774 = (long int) D.33773;
  D.33775 = __builtin_expect (D.33774, 0);
  if (D.33775 != 0) goto <D.33776>; else goto <D.33777>;
  <D.33776>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6834, "slot_index >= - MONO_IMT_SIZE");
  <D.33777>:
  vtable_trampolines.192 = vtable_trampolines;
  if (vtable_trampolines.192 == 0B) goto <D.33778>; else goto <D.33781>;
  <D.33781>:
  D.33782 = slot_index + 19;
  vtable_trampolines_size.193 = vtable_trampolines_size;
  if (D.33782 >= vtable_trampolines_size.193) goto <D.33778>; else goto <D.33779>;
  <D.33778>:
  {
    int ret;

    ret = pthread_mutex_lock (&jit_mutex.mutex);
    if (ret != 0) goto <D.33784>; else goto <D.33785>;
    <D.33784>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33785>:
    D.33786 = ret != 0;
    D.33787 = (long int) D.33786;
    D.33788 = __builtin_expect (D.33787, 0);
    if (D.33788 != 0) goto <D.33789>; else goto <D.33790>;
    <D.33789>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6836, "ret == 0");
    <D.33790>:
  }
  vtable_trampolines.192 = vtable_trampolines;
  if (vtable_trampolines.192 == 0B) goto <D.33791>; else goto <D.33793>;
  <D.33793>:
  vtable_trampolines_size.193 = vtable_trampolines_size;
  if (index >= vtable_trampolines_size.193) goto <D.33791>; else goto <D.33792>;
  <D.33791>:
  {
    int new_size;
    void * new_table;

    vtable_trampolines_size.193 = vtable_trampolines_size;
    if (vtable_trampolines_size.193 != 0) goto <D.33795>; else goto <D.33796>;
    <D.33795>:
    vtable_trampolines_size.193 = vtable_trampolines_size;
    iftmp.194 = vtable_trampolines_size.193 * 2;
    goto <D.33797>;
    <D.33796>:
    iftmp.194 = 128;
    <D.33797>:
    new_size = iftmp.194;
    goto <D.29050>;
    <D.29049>:
    new_size = new_size * 2;
    <D.29050>:
    if (new_size <= index) goto <D.29049>; else goto <D.29051>;
    <D.29051>:
    new_size.195 = (unsigned int) new_size;
    D.33799 = new_size.195 * 4;
    new_table = monoeg_malloc0 (D.33799);
    vtable_trampolines.192 = vtable_trampolines;
    if (vtable_trampolines.192 != 0B) goto <D.33800>; else goto <D.33801>;
    <D.33800>:
    vtable_trampolines.192 = vtable_trampolines;
    vtable_trampolines_size.193 = vtable_trampolines_size;
    vtable_trampolines_size.196 = (unsigned int) vtable_trampolines_size.193;
    D.33803 = vtable_trampolines_size.196 * 4;
    memcpy (new_table, vtable_trampolines.192, D.33803);
    <D.33801>:
    vtable_trampolines.192 = vtable_trampolines;
    monoeg_g_free (vtable_trampolines.192);
    mono_memory_barrier ();
    vtable_trampolines = new_table;
    vtable_trampolines_size = new_size;
  }
  <D.33792>:
  {
    int ret;

    ret = pthread_mutex_unlock (&jit_mutex.mutex);
    if (ret != 0) goto <D.33804>; else goto <D.33805>;
    <D.33804>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33805>:
    D.33806 = ret != 0;
    D.33807 = (long int) D.33806;
    D.33808 = __builtin_expect (D.33807, 0);
    if (D.33808 != 0) goto <D.33809>; else goto <D.33810>;
    <D.33809>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6853, "ret == 0");
    <D.33810>:
  }
  <D.33779>:
  vtable_trampolines.192 = vtable_trampolines;
  index.197 = (unsigned int) index;
  D.33812 = index.197 * 4;
  D.33813 = vtable_trampolines.192 + D.33812;
  D.33814 = *D.33813;
  if (D.33814 == 0B) goto <D.33815>; else goto <D.33816>;
  <D.33815>:
  vtable_trampolines.192 = vtable_trampolines;
  index.197 = (unsigned int) index;
  D.33812 = index.197 * 4;
  D.33813 = vtable_trampolines.192 + D.33812;
  slot_index.198 = (void *) slot_index;
  D.33818 = mono_get_root_domain ();
  D.33819 = mono_create_specific_trampoline (slot_index.198, 12, D.33818, 0B);
  *D.33813 = D.33819;
  <D.33816>:
  vtable_trampolines.192 = vtable_trampolines;
  index.197 = (unsigned int) index;
  D.33812 = index.197 * 4;
  D.33813 = vtable_trampolines.192 + D.33812;
  D.33820 = *D.33813;
  return D.33820;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mini_get_debug_options ()
{
  struct MonoDebugOptions * D.33822;

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


mini_init (const char * filename, const char * runtime_version)
{
  int D.33824;
  int default_opt_set.199;
  int D.33830;
  unsigned int default_opt.200;
  int mono_aot_only.201;
  struct MonoCodeManager * global_codeman.202;
  struct MonoCodeManager * global_codeman.203;
  struct GHashTable * jit_icall_name_hash.204;
  int mono_use_imt.205;
  const gchar * D.33843;
  const gchar * D.33846;
  struct MonoDebugOptions * D.33850;
  int D.33851;
  unsigned int default_opt.206;
  unsigned int D.33859;
  int D.33862;
  struct MonoCodeManager * D.33870;
  void * D.33876;
  void * D.33877;
  void * D.33878;
  int mono_compile_aot.207;
  struct MonoDomain * D.33882;
  struct MonoDomain * domain;
  struct MonoRuntimeCallbacks callbacks;
  struct MonoThreadInfoRuntimeCallbacks ticallbacks;

  try
    {
      D.33824 = access ("/proc/self/maps", 0);
      if (D.33824 != 0) goto <D.33825>; else goto <D.33826>;
      <D.33825>:
      monoeg_g_print ("Mono requires /proc to be mounted.\n");
      exit (1);
      <D.33826>:
      InitializeCriticalSection (&jit_mutex);
      default_opt_set.199 = default_opt_set;
      if (default_opt_set.199 == 0) goto <D.33828>; else goto <D.33829>;
      <D.33828>:
      D.33830 = mono_parse_default_optimizations (0B);
      default_opt.200 = (unsigned int) D.33830;
      default_opt = default_opt.200;
      <D.33829>:
      mono_aot_only.201 = mono_aot_only;
      if (mono_aot_only.201 != 0) goto <D.33833>; else goto <D.33834>;
      <D.33833>:
      mono_set_generic_sharing_vt_supported (1);
      <D.33834>:
      mono_runtime_set_has_tls_get (1);
      global_codeman.202 = global_codeman;
      if (global_codeman.202 == 0B) goto <D.33836>; else goto <D.33837>;
      <D.33836>:
      global_codeman.203 = mono_code_manager_new ();
      global_codeman = global_codeman.203;
      <D.33837>:
      jit_icall_name_hash.204 = 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.204;
      memset (&callbacks, 0, 32);
      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.205 = mono_use_imt;
      if (mono_use_imt.205 != 0) goto <D.33841>; else goto <D.33842>;
      <D.33841>:
      callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
      callbacks.get_imt_trampoline = mini_get_imt_trampoline;
      <D.33842>:
      mono_install_callbacks (&callbacks);
      memset (&ticallbacks, 0, 12);
      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.33843 = monoeg_g_getenv ("MONO_DEBUG");
      if (D.33843 != 0B) goto <D.33844>; else goto <D.33845>;
      <D.33844>:
      mini_parse_debug_options ();
      <D.33845>:
      mono_code_manager_init ();
      mono_hwcap_init ();
      mono_arch_cpu_init ();
      mono_arch_init ();
      mono_unwind_init ();
      D.33846 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.33846 != 0B) goto <D.33847>; else goto <D.33848>;
      <D.33847>:
      {
        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.33849>;
      <D.33848>:
      D.33850 = mini_get_debug_options ();
      D.33851 = D.33850->gdb;
      if (D.33851 != 0) goto <D.33852>; else goto <D.33853>;
      <D.33852>:
      mono_xdebug_init ("gdb");
      mono_dont_free_domains = 1;
      mono_using_xdebug = 1;
      <D.33853>:
      <D.33849>:
      mono_trampolines_init ();
      if (0 != 0) goto <D.33854>; else goto <D.33855>;
      <D.33854>:
      if (0 != 0) goto <D.33856>; else goto <D.33857>;
      <D.33856>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.29274>:
      goto <D.29274>;
      <D.33857>:
      <D.33855>:
      mono_native_tls_alloc (&mono_jit_tls_id, 0B);
      default_opt.206 = default_opt;
      D.33859 = default_opt.206 & 65536;
      if (D.33859 != 0) goto <D.33860>; else goto <D.33861>;
      <D.33860>:
      mono_aot_init ();
      <D.33861>:
      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.33862 = debug_options.collect_pagefault_stats;
      if (D.33862 != 0) goto <D.33863>; else goto <D.33864>;
      <D.33863>:
      mono_aot_set_make_unreadable (1);
      <D.33864>:
      if (runtime_version != 0B) goto <D.33865>; else goto <D.33866>;
      <D.33865>:
      domain = mono_init_version (filename, runtime_version);
      goto <D.33867>;
      <D.33866>:
      domain = mono_init_from_assembly (filename, filename);
      <D.33867>:
      mono_aot_only.201 = mono_aot_only;
      if (mono_aot_only.201 != 0) goto <D.33868>; else goto <D.33869>;
      <D.33868>:
      D.33870 = domain->code_mp;
      mono_code_manager_set_read_only (D.33870);
      mono_marshal_use_aot_wrappers (1);
      <D.33869>:
      mono_use_imt.205 = mono_use_imt;
      if (mono_use_imt.205 != 0) goto <D.33871>; else goto <D.33872>;
      <D.33871>:
      mono_aot_only.201 = mono_aot_only;
      if (mono_aot_only.201 != 0) goto <D.33873>; else goto <D.33874>;
      <D.33873>:
      mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
      goto <D.33875>;
      <D.33874>:
      mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
      <D.33875>:
      <D.33872>:
      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.33876 = mono_get_throw_exception ();
      register_dyn_icall (D.33876, "mono_arch_throw_exception", "void object", 1);
      D.33877 = mono_get_rethrow_exception ();
      register_dyn_icall (D.33877, "mono_arch_rethrow_exception", "void object", 1);
      D.33878 = mono_get_throw_corlib_exception ();
      register_dyn_icall (D.33878, "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 (481, "__emul_lmul", "long long long", mono_llmult, "mono_llmult", 1);
      register_opcode_emulation (482, "__emul_ldiv", "long long long", mono_lldiv, "mono_lldiv", 0);
      register_opcode_emulation (483, "__emul_ldiv_un", "long long long", mono_lldiv_un, "mono_lldiv_un", 0);
      register_opcode_emulation (484, "__emul_lrem", "long long long", mono_llrem, "mono_llrem", 0);
      register_opcode_emulation (485, "__emul_lrem_un", "long long long", mono_llrem_un, "mono_llrem_un", 0);
      register_opcode_emulation (510, "__emul_lmul_ovf_un", "long long long", mono_llmult_ovf_un, "mono_llmult_ovf_un", 0);
      register_opcode_emulation (509, "__emul_lmul_ovf", "long long long", mono_llmult_ovf, "mono_llmult_ovf", 0);
      register_opcode_emulation (489, "__emul_lshl", "long long int32", mono_lshl, "mono_lshl", 1);
      register_opcode_emulation (490, "__emul_lshr", "long long int32", mono_lshr, "mono_lshr", 1);
      register_opcode_emulation (491, "__emul_lshr_un", "long long int32", mono_lshr_un, "mono_lshr_un", 1);
      register_opcode_emulation (568, "__emul_op_idiv", "int32 int32 int32", mono_idiv, "mono_idiv", 0);
      register_opcode_emulation (569, "__emul_op_idiv_un", "int32 int32 int32", mono_idiv_un, "mono_idiv_un", 0);
      register_opcode_emulation (570, "__emul_op_irem", "int32 int32 int32", mono_irem, "mono_irem", 0);
      register_opcode_emulation (571, "__emul_op_irem_un", "int32 int32 int32", mono_irem_un, "mono_irem_un", 0);
      register_opcode_emulation (597, "__emul_op_imul_ovf", "int32 int32 int32", mono_imul_ovf, "mono_imul_ovf", 0);
      register_opcode_emulation (598, "__emul_op_imul_ovf_un", "int32 int32 int32", mono_imul_ovf_un, "mono_imul_ovf_un", 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 (680, "__emul_fconv_to_i8", "long double", mono_fconv_i8, "mono_fconv_i8", 0);
      register_opcode_emulation (588, "__emul_iconv_to_r_un", "double int32", mono_conv_to_r8_un, "mono_conv_to_r8_un", 0);
      register_opcode_emulation (499, "__emul_lconv_to_r8", "double long", mono_lconv_to_r8, "mono_lconv_to_r8", 0);
      register_opcode_emulation (498, "__emul_lconv_to_r4", "float long", mono_lconv_to_r4, "mono_lconv_to_r4", 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", "uint32 double", mono_fconv_u4, "mono_fconv_u4", 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.207 = mono_compile_aot;
      if (mono_compile_aot.207 != 0) goto <D.33880>; else goto <D.33881>;
      <D.33880>:
      mono_runtime_set_no_exec (1);
      <D.33881>:
      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.33882 = domain;
      return D.33882;
    }
  finally
    {
      callbacks = {CLOBBER};
      ticallbacks = {CLOBBER};
    }
}


mono_thread_attach_cb (intptr_t tid, void * stack_start)
{
  <unnamed type> D.33887;
  unsigned int D.33888;
  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.33885>; else goto <D.33886>;
  <D.33885>:
  thread->jit_data = jit_tls;
  <D.33886>:
  D.33887 = mono_profiler_get_events ();
  D.33888 = D.33887 & 32768;
  if (D.33888 != 0) goto <D.33889>; else goto <D.33890>;
  <D.33889>:
  mono_runtime_setup_stat_profiler ();
  <D.33890>:
  mono_arch_cpu_init ();
}


mono_thread_abort_dummy (struct MonoObject * obj)
{
  void (*<T4082>) (struct MonoObject *) mono_thread_attach_aborted_cb.208;

  mono_thread_attach_aborted_cb.208 = mono_thread_attach_aborted_cb;
  if (mono_thread_attach_aborted_cb.208 != 0B) goto <D.33892>; else goto <D.33893>;
  <D.33892>:
  mono_thread_attach_aborted_cb.208 = mono_thread_attach_aborted_cb;
  mono_thread_attach_aborted_cb.208 (obj);
  goto <D.33894>;
  <D.33893>:
  mono_thread_abort (obj);
  <D.33894>:
}


mono_thread_abort (struct MonoObject * obj)
{
  <unnamed type> D.33898;
  struct MonoVTable * D.33900;
  struct MonoClass * D.33901;
  struct MonoClass * D.33902;

  D.33898 = mono_runtime_unhandled_exception_policy_get ();
  if (D.33898 == 0) goto <D.33895>; else goto <D.33899>;
  <D.33899>:
  D.33900 = obj->vtable;
  D.33901 = D.33900->klass;
  D.33902 = mono_defaults.threadabortexception_class;
  if (D.33901 == D.33902) goto <D.33895>; else goto <D.33896>;
  <D.33895>:
  mono_thread_exit ();
  goto <D.33897>;
  <D.33896>:
  mono_invoke_unhandled_exception_hook (obj);
  <D.33897>:
}


setup_jit_tls_data (void * stack_start, void * abort_func)
{
  unsigned int mono_jit_tls_id.209;
  void * D.33906;
  void (*<T4082>) (struct MonoObject *) abort_func.210;
  struct MonoLMF * * D.33908;
  struct MonoJitTlsData * jit_tls;
  struct MonoLMF * lmf;

  mono_jit_tls_id.209 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.209);
  if (jit_tls != 0B) goto <D.33904>; else goto <D.33905>;
  <D.33904>:
  D.33906 = jit_tls;
  return D.33906;
  <D.33905>:
  jit_tls = monoeg_malloc0 (1136);
  abort_func.210 = (void (*<T4082>) (struct MonoObject *)) abort_func;
  jit_tls->abort_func = abort_func.210;
  jit_tls->end_of_stack = stack_start;
  mono_set_jit_tls (jit_tls);
  lmf = monoeg_malloc0 (208);
  jit_tls->first_lmf = lmf;
  D.33908 = &jit_tls->lmf;
  mono_set_lmf_addr (D.33908);
  jit_tls->lmf = lmf;
  mono_setup_altstack (jit_tls);
  D.33906 = jit_tls;
  return D.33906;
}


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

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


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.33911;
  int D.33912;
  _Bool D.33913;

  D.33912 = pthread_setspecific (key, value);
  D.33913 = D.33912 == 0;
  D.33911 = (int) D.33913;
  return D.33911;
}


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


mono_jit_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  void * obj.212;
  short unsigned int D.33920;
  int D.33921;
  int D.33922;
  unsigned char D.33925;
  unsigned char D.33926;
  struct MonoObject * D.33929;
  union mono_mutex_t * D.33930;
  _Bool D.33933;
  long int D.33934;
  long int D.33935;
  struct GHashTable * D.33938;
  _Bool D.33941;
  long int D.33942;
  long int D.33943;
  <unnamed type> D.33948;
  struct MonoClass * D.33951;
  unsigned char D.33952;
  struct MonoException * D.33957;
  struct MonoException * D.33959;
  struct MonoVTable * D.33960;
  struct MonoVTable * D.33961;
  _Bool D.33962;
  long int D.33963;
  long int D.33964;
  unsigned char D.33967;
  short unsigned int D.33970;
  unsigned int D.33971;
  unsigned int D.33972;
  int mono_aot_only.213;
  unsigned int default_opt.214;
  unsigned int D.33982;
  void * D.33983;
  void * D.33984;
  struct MonoException * jit_ex.215;
  _Bool D.33988;
  long int D.33989;
  long int D.33990;
  int D.33995;
  void * D.33996;
  int D.34001;
  unsigned char D.34002;
  unsigned char D.34005;
  struct MonoClass * D.34008;
  int D.34009;
  short unsigned int D.34012;
  int D.34013;
  unsigned char D.34016;
  unsigned char D.34017;
  struct MonoDynCallInfo * D.34021;
  struct MonoDynCallInfo * D.34022;
  unsigned char D.34025;
  int D.34026;
  struct MonoClass * D.34027;
  struct MonoClass * D.34028;
  int D.34029;
  struct MonoClass * D.34032;
  struct MonoClass * D.34033;
  void * D.34036;
  _Bool D.34039;
  long int D.34040;
  long int D.34041;
  _Bool D.34049;
  long int D.34050;
  long int D.34051;
  void * D.34054;
  struct MonoException * D.34057;
  struct MonoObject * D.34058;
  void (*<T3cf6>) (void *, struct MonoObject * *, void *) dyn_runtime_invoke.216;
  void * D.34069;
  void (*<T3cf6>) (void *, struct MonoObject * *, void *) dyn_runtime_invoke.217;
  short unsigned int D.34071;
  int D.34072;
  <unnamed-unsigned:1> D.34073;
  int D.34074;
  int D.34075;
  unsigned int D.34076;
  unsigned int D.34077;
  unsigned char D.34078;
  unsigned char D.34079;
  int pindex.218;
  unsigned int pindex.219;
  unsigned int D.34084;
  void * * D.34085;
  unsigned char D.34086;
  unsigned char D.34087;
  int pindex.220;
  unsigned int pindex.221;
  unsigned int D.34092;
  void * * D.34093;
  unsigned int i.222;
  unsigned int D.34095;
  void * D.34096;
  int D.34101;
  unsigned char D.34103;
  int pindex.223;
  unsigned int pindex.224;
  unsigned int D.34106;
  void * * D.34107;
  int pindex.225;
  unsigned int pindex.226;
  unsigned int D.34110;
  void * * D.34111;
  void * * D.34112;
  void * D.34113;
  struct MonoClass * D.34114;
  guint8[128] * retval.227;
  struct MonoMethod * invoke;
  struct MonoMethod * callee;
  struct MonoObject * (*<T3cf1>) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;
  struct MonoDomain * domain;
  struct MonoJitDomainInfo * domain_info;
  struct RuntimeInvokeInfo * info;
  struct RuntimeInvokeInfo * info2;

  domain = mono_domain_get ();
  obj.212 = obj;
  if (obj.212 == 0B) goto <D.33918>; else goto <D.33919>;
  <D.33918>:
  D.33920 = method->flags;
  D.33921 = (int) D.33920;
  D.33922 = D.33921 & 16;
  if (D.33922 == 0) goto <D.33923>; else goto <D.33924>;
  <D.33923>:
  D.33925 = BIT_FIELD_REF <*method, 8, 160>;
  D.33926 = D.33925 & 252;
  if (D.33926 == 0) goto <D.33927>; else goto <D.33928>;
  <D.33927>:
  monoeg_g_log (0B, 16, "Ignoring invocation of an instance method on a NULL instance.\n");
  D.33929 = 0B;
  return D.33929;
  <D.33928>:
  <D.33924>:
  <D.33919>:
  domain_info = domain->runtime_info;
  {
    int ret;

    D.33930 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.33930);
    if (ret != 0) goto <D.33931>; else goto <D.33932>;
    <D.33931>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33932>:
    D.33933 = ret != 0;
    D.33934 = (long int) D.33933;
    D.33935 = __builtin_expect (D.33934, 0);
    if (D.33935 != 0) goto <D.33936>; else goto <D.33937>;
    <D.33936>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6436, "ret == 0");
    <D.33937>:
  }
  D.33938 = domain_info->runtime_invoke_hash;
  info = monoeg_g_hash_table_lookup (D.33938, method);
  {
    int ret;

    D.33930 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.33930);
    if (ret != 0) goto <D.33939>; else goto <D.33940>;
    <D.33939>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33940>:
    D.33941 = ret != 0;
    D.33942 = (long int) D.33941;
    D.33943 = __builtin_expect (D.33942, 0);
    if (D.33943 != 0) goto <D.33944>; else goto <D.33945>;
    <D.33944>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6438, "ret == 0");
    <D.33945>:
  }
  if (info == 0B) goto <D.33946>; else goto <D.33947>;
  <D.33946>:
  D.33948 = mono_security_get_mode ();
  if (D.33948 == 1) goto <D.33949>; else goto <D.33950>;
  <D.33949>:
  D.33951 = method->klass;
  mono_class_setup_vtable (D.33951);
  D.33951 = method->klass;
  D.33952 = D.33951->exception_type;
  if (D.33952 != 0) goto <D.33953>; else goto <D.33954>;
  <D.33953>:
  if (exc != 0B) goto <D.33955>; else goto <D.33956>;
  <D.33955>:
  D.33951 = method->klass;
  D.33957 = mono_class_get_exception_for_failure (D.33951);
  *exc = D.33957;
  goto <D.33958>;
  <D.33956>:
  D.33951 = method->klass;
  D.33959 = mono_class_get_exception_for_failure (D.33951);
  mono_raise_exception (D.33959);
  <D.33958>:
  D.33929 = 0B;
  return D.33929;
  <D.33954>:
  <D.33950>:
  info = monoeg_malloc0 (24);
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  D.33951 = method->klass;
  D.33960 = mono_class_vtable_full (domain, D.33951, 1);
  info->vtable = D.33960;
  D.33961 = info->vtable;
  D.33962 = D.33961 == 0B;
  D.33963 = (long int) D.33962;
  D.33964 = __builtin_expect (D.33963, 0);
  if (D.33964 != 0) goto <D.33965>; else goto <D.33966>;
  <D.33965>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6460, "info->vtable");
  <D.33966>:
  callee = method;
  D.33951 = method->klass;
  D.33967 = D.33951->rank;
  if (D.33967 != 0) goto <D.33968>; else goto <D.33969>;
  <D.33968>:
  D.33970 = method->iflags;
  D.33971 = (unsigned int) D.33970;
  D.33972 = D.33971 & 4097;
  if (D.33972 == 4097) goto <D.33973>; else goto <D.33974>;
  <D.33973>:
  mono_aot_only.213 = mono_aot_only;
  if (mono_aot_only.213 != 0) goto <D.33976>; else goto <D.33977>;
  <D.33976>:
  {
    struct MonoMethod * wrapper;

    wrapper = mono_marshal_get_array_accessor_wrapper (method);
    invoke = mono_marshal_get_runtime_invoke (wrapper, 0);
    callee = wrapper;
  }
  goto <D.33978>;
  <D.33977>:
  callee = 0B;
  <D.33978>:
  <D.33974>:
  <D.33969>:
  if (callee != 0B) goto <D.33979>; else goto <D.33980>;
  <D.33979>:
  {
    struct MonoException * jit_ex;

    try
      {
        jit_ex = 0B;
        default_opt.214 = default_opt;
        D.33982 = mono_get_optimizations_for_method (callee, default_opt.214);
        D.33983 = mono_jit_compile_method_with_opt (callee, D.33982, &jit_ex);
        info->compiled_method = D.33983;
        D.33984 = info->compiled_method;
        if (D.33984 == 0B) goto <D.33985>; else goto <D.33986>;
        <D.33985>:
        monoeg_g_free (info);
        jit_ex.215 = jit_ex;
        D.33988 = jit_ex.215 == 0B;
        D.33989 = (long int) D.33988;
        D.33990 = __builtin_expect (D.33989, 0);
        if (D.33990 != 0) goto <D.33991>; else goto <D.33992>;
        <D.33991>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6489, "jit_ex");
        <D.33992>:
        if (exc != 0B) goto <D.33993>; else goto <D.33994>;
        <D.33993>:
        jit_ex.215 = jit_ex;
        *exc = jit_ex.215;
        D.33929 = 0B;
        return D.33929;
        <D.33994>:
        jit_ex.215 = jit_ex;
        mono_raise_exception (jit_ex.215);
        <D.33986>:
        D.33984 = info->compiled_method;
        D.33995 = mono_method_needs_static_rgctx_invoke (callee, 0);
        D.33996 = mini_add_method_trampoline (0B, callee, D.33984, D.33995, 0);
        info->compiled_method = D.33996;
      }
    finally
      {
        jit_ex = {CLOBBER};
      }
  }
  goto <D.33997>;
  <D.33980>:
  info->compiled_method = 0B;
  <D.33997>:
  mono_aot_only.213 = mono_aot_only;
  if (mono_aot_only.213 != 0) goto <D.33998>; else goto <D.34000>;
  <D.34000>:
  D.34001 = debug_options.dyn_runtime_invoke;
  if (D.34001 != 0) goto <D.33998>; else goto <D.33999>;
  <D.33998>:
  {
    struct MonoType * ret_type;
    struct MonoMethodSignature * sig;
    gboolean supported;
    int i;

    sig = mono_method_signature (method);
    supported = 1;
    D.33925 = BIT_FIELD_REF <*method, 8, 160>;
    D.34002 = D.33925 & 128;
    if (D.34002 != 0) goto <D.34003>; else goto <D.34004>;
    <D.34003>:
    sig = mono_marshal_get_string_ctor_signature (method);
    <D.34004>:
    i = 0;
    goto <D.28962>;
    <D.28961>:
    {
      struct MonoType * t;

      t = sig->params[i];
      D.34005 = t->type;
      if (D.34005 == 21) goto <D.34006>; else goto <D.34007>;
      <D.34006>:
      D.34008 = mono_class_from_mono_type (t);
      D.34009 = mono_class_is_nullable (D.34008);
      if (D.34009 != 0) goto <D.34010>; else goto <D.34011>;
      <D.34010>:
      supported = 0;
      <D.34011>:
      <D.34007>:
    }
    i = i + 1;
    <D.28962>:
    D.34012 = sig->param_count;
    D.34013 = (int) D.34012;
    if (D.34013 > i) goto <D.28961>; else goto <D.28963>;
    <D.28963>:
    D.33951 = method->klass;
    D.34016 = BIT_FIELD_REF <*D.33951, 8, 176>;
    D.34017 = D.34016 & 128;
    if (D.34017 != 0) goto <D.34014>; else goto <D.34018>;
    <D.34018>:
    D.33984 = info->compiled_method;
    if (D.33984 == 0B) goto <D.34014>; else goto <D.34015>;
    <D.34014>:
    supported = 0;
    <D.34015>:
    if (supported != 0) goto <D.34019>; else goto <D.34020>;
    <D.34019>:
    D.34021 = mono_arch_dyn_call_prepare (sig);
    info->dyn_call_info = D.34021;
    <D.34020>:
    ret_type = sig->ret;
    D.34022 = info->dyn_call_info;
    if (D.34022 != 0B) goto <D.34023>; else goto <D.34024>;
    <D.34023>:
    D.34025 = ret_type->type;
    D.34026 = (int) D.34025;
    switch (D.34026) <default: <D.28988>, case 1: <D.28964>, case 2: <D.28976>, case 3: <D.28977>, case 4: <D.28966>, case 5: <D.28967>, case 6: <D.28968>, case 7: <D.28969>, case 8: <D.28970>, case 9: <D.28971>, case 10: <D.28974>, case 11: <D.28975>, case 12: <D.28978>, case 13: <D.28979>, case 14: <D.28981>, case 15: <D.28980>, case 17: <D.28987>, case 18: <D.28982>, case 20: <D.28983>, case 21: <D.28986>, case 24: <D.28972>, case 25: <D.28973>, case 28: <D.28985>, case 29: <D.28984>>
    <D.28964>:
    goto <D.28965>;
    <D.28966>:
    <D.28967>:
    <D.28968>:
    <D.28969>:
    <D.28970>:
    <D.28971>:
    <D.28972>:
    <D.28973>:
    <D.28974>:
    <D.28975>:
    <D.28976>:
    <D.28977>:
    <D.28978>:
    <D.28979>:
    D.34027 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.34027;
    goto <D.28965>;
    <D.28980>:
    D.34028 = mono_defaults.int_class;
    info->ret_box_class = D.34028;
    goto <D.28965>;
    <D.28981>:
    <D.28982>:
    <D.28983>:
    <D.28984>:
    <D.28985>:
    goto <D.28965>;
    <D.28986>:
    D.34029 = mono_type_is_reference (ret_type);
    if (D.34029 == 0) goto <D.34030>; else goto <D.34031>;
    <D.34030>:
    D.34032 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.34032;
    <D.34031>:
    goto <D.28965>;
    <D.28987>:
    D.34033 = mono_class_from_mono_type (ret_type);
    info->ret_box_class = D.34033;
    goto <D.28965>;
    <D.28988>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini.c", 6569);
    <D.28965>:
    <D.34024>:
  }
  <D.33999>:
  D.34022 = info->dyn_call_info;
  if (D.34022 == 0B) goto <D.34034>; else goto <D.34035>;
  <D.34034>:
  D.34036 = mono_jit_compile_method (invoke);
  info->runtime_invoke = D.34036;
  <D.34035>:
  {
    int ret;

    D.33930 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.33930);
    if (ret != 0) goto <D.34037>; else goto <D.34038>;
    <D.34037>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.34038>:
    D.34039 = ret != 0;
    D.34040 = (long int) D.34039;
    D.34041 = __builtin_expect (D.34040, 0);
    if (D.34041 != 0) goto <D.34042>; else goto <D.34043>;
    <D.34042>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6579, "ret == 0");
    <D.34043>:
  }
  D.33938 = domain_info->runtime_invoke_hash;
  info2 = monoeg_g_hash_table_lookup (D.33938, method);
  if (info2 != 0B) goto <D.34044>; else goto <D.34045>;
  <D.34044>:
  monoeg_g_free (info);
  info = info2;
  goto <D.34046>;
  <D.34045>:
  D.33938 = domain_info->runtime_invoke_hash;
  monoeg_g_hash_table_insert_replace (D.33938, method, info, 0);
  <D.34046>:
  {
    int ret;

    D.33930 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.33930);
    if (ret != 0) goto <D.34047>; else goto <D.34048>;
    <D.34047>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.34048>:
    D.34049 = ret != 0;
    D.34050 = (long int) D.34049;
    D.34051 = __builtin_expect (D.34050, 0);
    if (D.34051 != 0) goto <D.34052>; else goto <D.34053>;
    <D.34052>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6587, "ret == 0");
    <D.34053>:
  }
  <D.33947>:
  D.34054 = info->runtime_invoke;
  runtime_invoke = (struct MonoObject * (*<T3cf1>) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.34054;
  if (exc != 0B) goto <D.34055>; else goto <D.34056>;
  <D.34055>:
  D.33961 = info->vtable;
  D.34057 = mono_runtime_class_init_full (D.33961, 0);
  *exc = D.34057;
  D.34058 = *exc;
  if (D.34058 != 0B) goto <D.34059>; else goto <D.34060>;
  <D.34059>:
  D.33929 = 0B;
  return D.33929;
  <D.34060>:
  goto <D.34061>;
  <D.34056>:
  D.33961 = info->vtable;
  mono_runtime_class_init (D.33961);
  <D.34061>:
  if (exc != 0B) goto <D.34062>; else goto <D.34063>;
  <D.34062>:
  *exc = 0B;
  <D.34063>:
  D.34022 = info->dyn_call_info;
  if (D.34022 != 0B) goto <D.34064>; else goto <D.34065>;
  <D.34064>:
  {
    struct MonoMethodSignature * sig;
    void * * args;
    static void (*RuntimeInvokeDynamicFunction) (void *, struct MonoObject * *, void *) dyn_runtime_invoke;
    int i;
    int pindex;
    guint8 buf[128];
    guint8 retval[128];

    try
      {
        sig = mono_method_signature (method);
        dyn_runtime_invoke.216 = dyn_runtime_invoke;
        if (dyn_runtime_invoke.216 == 0B) goto <D.34067>; else goto <D.34068>;
        <D.34067>:
        invoke = mono_marshal_get_runtime_invoke_dynamic ();
        D.34069 = mono_jit_compile_method (invoke);
        dyn_runtime_invoke.217 = (void (*<T3cf6>) (void *, struct MonoObject * *, void *)) D.34069;
        dyn_runtime_invoke = dyn_runtime_invoke.217;
        <D.34068>:
        D.34071 = sig->param_count;
        D.34072 = (int) D.34071;
        D.34073 = sig->hasthis;
        D.34074 = (int) D.34073;
        D.34075 = D.34072 + D.34074;
        D.34076 = (unsigned int) D.34075;
        D.34077 = D.34076 * 4;
        args = __builtin_alloca (D.34077);
        pindex = 0;
        D.34078 = BIT_FIELD_REF <*sig, 8, 80>;
        D.34079 = D.34078 & 64;
        if (D.34079 != 0) goto <D.34080>; else goto <D.34081>;
        <D.34080>:
        pindex.218 = pindex;
        pindex = pindex.218 + 1;
        pindex.219 = (unsigned int) pindex.218;
        D.34084 = pindex.219 * 4;
        D.34085 = args + D.34084;
        *D.34085 = &obj;
        <D.34081>:
        i = 0;
        goto <D.29000>;
        <D.28999>:
        {
          struct MonoType * t;

          t = sig->params[i];
          D.34086 = BIT_FIELD_REF <*t, 8, 56>;
          D.34087 = D.34086 & 64;
          if (D.34087 != 0) goto <D.34088>; else goto <D.34089>;
          <D.34088>:
          pindex.220 = pindex;
          pindex = pindex.220 + 1;
          pindex.221 = (unsigned int) pindex.220;
          D.34092 = pindex.221 * 4;
          D.34093 = args + D.34092;
          i.222 = (unsigned int) i;
          D.34095 = i.222 * 4;
          D.34096 = params + D.34095;
          *D.34093 = D.34096;
          goto <D.34097>;
          <D.34089>:
          D.34101 = mono_type_is_reference (t);
          if (D.34101 != 0) goto <D.34098>; else goto <D.34102>;
          <D.34102>:
          D.34103 = t->type;
          if (D.34103 == 15) goto <D.34098>; else goto <D.34099>;
          <D.34098>:
          pindex.223 = pindex;
          pindex = pindex.223 + 1;
          pindex.224 = (unsigned int) pindex.223;
          D.34106 = pindex.224 * 4;
          D.34107 = args + D.34106;
          i.222 = (unsigned int) i;
          D.34095 = i.222 * 4;
          D.34096 = params + D.34095;
          *D.34107 = D.34096;
          goto <D.34100>;
          <D.34099>:
          pindex.225 = pindex;
          pindex = pindex.225 + 1;
          pindex.226 = (unsigned int) pindex.225;
          D.34110 = pindex.226 * 4;
          D.34111 = args + D.34110;
          i.222 = (unsigned int) i;
          D.34095 = i.222 * 4;
          D.34112 = params + D.34095;
          D.34113 = *D.34112;
          *D.34111 = D.34113;
          <D.34100>:
          <D.34097>:
        }
        i = i + 1;
        <D.29000>:
        D.34071 = sig->param_count;
        D.34072 = (int) D.34071;
        if (D.34072 > i) goto <D.28999>; else goto <D.29001>;
        <D.29001>:
        D.34022 = info->dyn_call_info;
        mono_arch_start_dyn_call (D.34022, args, &retval, &buf, 128);
        dyn_runtime_invoke.216 = dyn_runtime_invoke;
        D.33984 = info->compiled_method;
        dyn_runtime_invoke.216 (&buf, exc, D.33984);
        D.34022 = info->dyn_call_info;
        mono_arch_finish_dyn_call (D.34022, &buf);
        D.34114 = info->ret_box_class;
        if (D.34114 != 0B) goto <D.34115>; else goto <D.34116>;
        <D.34115>:
        D.34114 = info->ret_box_class;
        D.33929 = mono_value_box (domain, D.34114, &retval);
        return D.33929;
        <D.34116>:
        retval.227 = &retval;
        D.33929 = MEM[(struct MonoObject * *)retval.227];
        return D.33929;
      }
    finally
      {
        buf = {CLOBBER};
        retval = {CLOBBER};
      }
  }
  <D.34065>:
  obj.212 = obj;
  D.33984 = info->compiled_method;
  D.33929 = runtime_invoke (obj.212, params, exc, D.33984);
  return D.33929;
}


mini_free_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.34123;
  struct GHashTable * D.34124;
  struct GHashTable * D.34127;
  struct GHashTable * D.34130;
  struct GHashTable * D.34133;
  struct GHashTable * D.34134;
  struct GHashTable * D.34135;
  struct GHashTable * D.34136;
  struct GHashTable * D.34137;
  struct GHashTable * D.34140;
  struct GHashTable * D.34141;
  struct GHashTable * D.34142;
  struct GHashTable * D.34143;
  void * D.34144;
  struct GHashTable * D.34147;
  void * D.34150;
  struct MonoJitDomainInfo * info;

  info = domain->runtime_info;
  D.34123 = info->jump_target_hash;
  monoeg_g_hash_table_foreach (D.34123, delete_jump_list, 0B);
  D.34123 = info->jump_target_hash;
  monoeg_g_hash_table_destroy (D.34123);
  D.34124 = info->jump_target_got_slot_hash;
  if (D.34124 != 0B) goto <D.34125>; else goto <D.34126>;
  <D.34125>:
  D.34124 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_foreach (D.34124, delete_got_slot_list, 0B);
  D.34124 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_destroy (D.34124);
  <D.34126>:
  D.34127 = info->dynamic_code_hash;
  if (D.34127 != 0B) goto <D.34128>; else goto <D.34129>;
  <D.34128>:
  D.34127 = info->dynamic_code_hash;
  monoeg_g_hash_table_foreach (D.34127, dynamic_method_info_free, 0B);
  D.34127 = info->dynamic_code_hash;
  monoeg_g_hash_table_destroy (D.34127);
  <D.34129>:
  D.34130 = info->method_code_hash;
  if (D.34130 != 0B) goto <D.34131>; else goto <D.34132>;
  <D.34131>:
  D.34130 = info->method_code_hash;
  monoeg_g_hash_table_destroy (D.34130);
  <D.34132>:
  D.34133 = info->class_init_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34133);
  D.34134 = info->jump_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34134);
  D.34135 = info->jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34135);
  D.34136 = info->delegate_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34136);
  D.34137 = info->static_rgctx_trampoline_hash;
  if (D.34137 != 0B) goto <D.34138>; else goto <D.34139>;
  <D.34138>:
  D.34137 = info->static_rgctx_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34137);
  <D.34139>:
  D.34140 = info->llvm_vcall_trampoline_hash;
  monoeg_g_hash_table_destroy (D.34140);
  D.34141 = info->runtime_invoke_hash;
  monoeg_g_hash_table_destroy (D.34141);
  D.34142 = info->seq_points;
  monoeg_g_hash_table_destroy (D.34142);
  D.34143 = info->arch_seq_points;
  monoeg_g_hash_table_destroy (D.34143);
  D.34144 = info->agent_info;
  if (D.34144 != 0B) goto <D.34145>; else goto <D.34146>;
  <D.34145>:
  mono_debugger_agent_free_domain_info (domain);
  <D.34146>:
  D.34147 = info->gsharedvt_arg_tramp_hash;
  if (D.34147 != 0B) goto <D.34148>; else goto <D.34149>;
  <D.34148>:
  D.34147 = info->gsharedvt_arg_tramp_hash;
  monoeg_g_hash_table_destroy (D.34147);
  <D.34149>:
  D.34150 = domain->runtime_info;
  monoeg_g_free (D.34150);
  domain->runtime_info = 0B;
}


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

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

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


mini_create_jit_domain_info (struct MonoDomain * domain)
{
  struct GHashTable * D.34153;
  struct GHashTable * D.34154;
  struct GHashTable * D.34155;
  struct GHashTable * D.34156;
  struct GHashTable * D.34157;
  struct GHashTable * D.34158;
  struct GHashTable * D.34159;
  struct GHashTable * D.34160;
  struct GHashTable * D.34161;
  struct MonoJitDomainInfo * info;

  info = monoeg_malloc0 (196);
  D.34153 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->class_init_trampoline_hash = D.34153;
  D.34154 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jump_trampoline_hash = D.34154;
  D.34155 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->jit_trampoline_hash = D.34155;
  D.34156 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->delegate_trampoline_hash = D.34156;
  D.34157 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->llvm_vcall_trampoline_hash = D.34157;
  D.34158 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, runtime_invoke_info_free);
  info->runtime_invoke_hash = D.34158;
  D.34159 = monoeg_g_hash_table_new_full (mono_aligned_addr_hash, 0B, 0B, seq_point_info_free);
  info->seq_points = D.34159;
  D.34160 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->arch_seq_points = D.34160;
  D.34161 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_hash = D.34161;
  domain->runtime_info = info;
}


seq_point_info_free (void * value)
{
  int * D.34162;
  int D.34163;
  int i;
  struct MonoSeqPointInfo * info;

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

    sp = &info->seq_points[i];
    D.34162 = sp->next;
    monoeg_g_free (D.34162);
  }
  i = i + 1;
  <D.29260>:
  D.34163 = info->len;
  if (D.34163 > i) goto <D.29259>; else goto <D.29261>;
  <D.29261>:
  monoeg_g_free (info);
}


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

  info = value;
  D.34164 = info->dyn_call_info;
  if (D.34164 != 0B) goto <D.34165>; else goto <D.34166>;
  <D.34165>:
  D.34164 = info->dyn_call_info;
  mono_arch_dyn_call_free (D.34164);
  <D.34166>:
  monoeg_g_free (info);
}


mono_jit_create_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  short unsigned int D.34167;
  int D.34168;
  int D.34169;
  struct MonoMethodSignature * D.34172;
  short unsigned int D.34173;
  void * D.34176;
  int D.34180;
  struct MonoMethodSignature * D.34182;
  unsigned char D.34183;
  unsigned char D.34184;
  struct MonoClass * D.34186;
  unsigned char D.34187;
  unsigned char D.34188;
  struct MonoClass * D.34190;
  struct MonoMethod * nm;
  guint8 * addr;

  addr = 0B;
  D.34167 = method->flags;
  D.34168 = (int) D.34167;
  D.34169 = D.34168 & 64;
  if (D.34169 != 0) goto <D.34170>; else goto <D.34171>;
  <D.34170>:
  D.34172 = mono_method_signature (method);
  D.34173 = D.34172->generic_param_count;
  if (D.34173 != 0) goto <D.34174>; else goto <D.34175>;
  <D.34174>:
  D.34176 = mono_create_specific_trampoline (method, 9, domain, 0B);
  return D.34176;
  <D.34175>:
  <D.34171>:
  D.34167 = method->flags;
  D.34168 = (int) D.34167;
  D.34180 = D.34168 & 1024;
  if (D.34180 != 0) goto <D.34177>; else goto <D.34181>;
  <D.34181>:
  D.34182 = mono_method_signature (method);
  D.34183 = BIT_FIELD_REF <*D.34182, 8, 80>;
  D.34184 = D.34183 & 64;
  if (D.34184 != 0) goto <D.34185>; else goto <D.34178>;
  <D.34185>:
  D.34186 = method->klass;
  D.34187 = BIT_FIELD_REF <*D.34186, 8, 176>;
  D.34188 = D.34187 & 64;
  if (D.34188 != 0) goto <D.34177>; else goto <D.34189>;
  <D.34189>:
  D.34186 = method->klass;
  D.34190 = mono_defaults.object_class;
  if (D.34186 == D.34190) goto <D.34177>; else goto <D.34178>;
  <D.34177>:
  nm = mono_marshal_get_remoting_invoke_for_target (method, target);
  addr = mono_compile_method (nm);
  goto <D.34179>;
  <D.34178>:
  addr = mono_compile_method (method);
  <D.34179>:
  D.34176 = mono_get_addr_from_ftnptr (addr);
  return D.34176;
}


mono_jit_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.34192;
  unsigned char D.34193;
  _Bool D.34194;
  long int D.34195;
  long int D.34196;
  union mono_mutex_t * D.34199;
  _Bool D.34202;
  long int D.34203;
  long int D.34204;
  _Bool D.34209;
  long int D.34210;
  long int D.34211;
  _Bool D.34218;
  long int D.34219;
  long int D.34220;
  void * D.34223;
  struct GHashTable * D.34224;
  struct MonoInternalHashTable * D.34225;
  struct GHashTable * D.34226;
  struct GHashTable * D.34227;
  struct GHashTable * D.34228;
  struct MonoJumpList * jlist.228;
  struct MonoJitInfo * D.34230;
  void * D.34231;
  int D.34234;
  sizetype D.34235;
  guint8 * D.34236;
  struct GSList * D.34239;
  void * D.34240;
  struct GSList * D.34241;
  int D.34242;
  _Bool D.34245;
  long int D.34246;
  long int D.34247;
  struct MonoCodeManager * D.34252;
  struct MonoJitDynamicMethodInfo * ji;
  gboolean destroy;
  struct GHashTableIter iter;
  struct MonoJumpList * jlist;

  try
    {
      destroy = 1;
      D.34192 = BIT_FIELD_REF <*method, 8, 168>;
      D.34193 = D.34192 & 2;
      D.34194 = D.34193 == 0;
      D.34195 = (long int) D.34194;
      D.34196 = __builtin_expect (D.34195, 0);
      if (D.34196 != 0) goto <D.34197>; else goto <D.34198>;
      <D.34197>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6280, "method->dynamic");
      <D.34198>:
      {
        int ret;

        D.34199 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.34199);
        if (ret != 0) goto <D.34200>; else goto <D.34201>;
        <D.34200>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.34201>:
        D.34202 = ret != 0;
        D.34203 = (long int) D.34202;
        D.34204 = __builtin_expect (D.34203, 0);
        if (D.34204 != 0) goto <D.34205>; else goto <D.34206>;
        <D.34205>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6282, "ret == 0");
        <D.34206>:
      }
      ji = mono_dynamic_code_hash_lookup (domain, method);
      {
        int ret;

        D.34199 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.34199);
        if (ret != 0) goto <D.34207>; else goto <D.34208>;
        <D.34207>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.34208>:
        D.34209 = ret != 0;
        D.34210 = (long int) D.34209;
        D.34211 = __builtin_expect (D.34210, 0);
        if (D.34211 != 0) goto <D.34212>; else goto <D.34213>;
        <D.34212>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6284, "ret == 0");
        <D.34213>:
      }
      if (ji == 0B) goto <D.34214>; else goto <D.34215>;
      <D.34214>:
      return;
      <D.34215>:
      mono_debug_remove_method (method, domain);
      {
        int ret;

        D.34199 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.34199);
        if (ret != 0) goto <D.34216>; else goto <D.34217>;
        <D.34216>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.34217>:
        D.34218 = ret != 0;
        D.34219 = (long int) D.34218;
        D.34220 = __builtin_expect (D.34219, 0);
        if (D.34220 != 0) goto <D.34221>; else goto <D.34222>;
        <D.34221>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6291, "ret == 0");
        <D.34222>:
      }
      D.34223 = domain->runtime_info;
      D.34224 = MEM[(struct MonoJitDomainInfo *)D.34223].dynamic_code_hash;
      monoeg_g_hash_table_remove (D.34224, method);
      D.34225 = &domain->jit_code_hash;
      mono_internal_hash_table_remove (D.34225, method);
      D.34223 = domain->runtime_info;
      D.34226 = MEM[(struct MonoJitDomainInfo *)D.34223].jump_trampoline_hash;
      monoeg_g_hash_table_remove (D.34226, method);
      D.34223 = domain->runtime_info;
      D.34227 = MEM[(struct MonoJitDomainInfo *)D.34223].runtime_invoke_hash;
      monoeg_g_hash_table_remove (D.34227, method);
      D.34223 = domain->runtime_info;
      D.34228 = MEM[(struct MonoJitDomainInfo *)D.34223].jump_target_hash;
      monoeg_g_hash_table_iter_init (&iter, D.34228);
      goto <D.28904>;
      <D.28903>:
      {
        struct GSList * tmp;
        struct GSList * remove;

        remove = 0B;
        jlist.228 = jlist;
        tmp = jlist.228->list;
        goto <D.28898>;
        <D.28897>:
        {
          guint8 * ip;

          ip = tmp->data;
          D.34230 = ji->ji;
          D.34231 = D.34230->code_start;
          if (D.34231 <= ip) goto <D.34232>; else goto <D.34233>;
          <D.34232>:
          D.34230 = ji->ji;
          D.34231 = D.34230->code_start;
          D.34230 = ji->ji;
          D.34234 = D.34230->code_size;
          D.34235 = (sizetype) D.34234;
          D.34236 = D.34231 + D.34235;
          if (D.34236 > ip) goto <D.34237>; else goto <D.34238>;
          <D.34237>:
          remove = monoeg_g_slist_prepend (remove, tmp);
          <D.34238>:
          <D.34233>:
        }
        tmp = tmp->next;
        <D.28898>:
        if (tmp != 0B) goto <D.28897>; else goto <D.28899>;
        <D.28899>:
        tmp = remove;
        goto <D.28901>;
        <D.28900>:
        jlist.228 = jlist;
        jlist.228 = jlist;
        D.34239 = jlist.228->list;
        D.34240 = tmp->data;
        D.34241 = monoeg_g_slist_delete_link (D.34239, D.34240);
        jlist.228->list = D.34241;
        tmp = tmp->next;
        <D.28901>:
        if (tmp != 0B) goto <D.28900>; else goto <D.28902>;
        <D.28902>:
        monoeg_g_slist_free (remove);
      }
      <D.28904>:
      D.34242 = monoeg_g_hash_table_iter_next (&iter, 0B, &jlist);
      if (D.34242 != 0) goto <D.28903>; else goto <D.28905>;
      <D.28905>:
      {
        int ret;

        D.34199 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.34199);
        if (ret != 0) goto <D.34243>; else goto <D.34244>;
        <D.34243>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.34244>:
        D.34245 = ret != 0;
        D.34246 = (long int) D.34245;
        D.34247 = __builtin_expect (D.34246, 0);
        if (D.34247 != 0) goto <D.34248>; else goto <D.34249>;
        <D.34248>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 6315, "ret == 0");
        <D.34249>:
      }
      D.34230 = ji->ji;
      mono_jit_info_table_remove (domain, D.34230);
      if (destroy != 0) goto <D.34250>; else goto <D.34251>;
      <D.34250>:
      D.34252 = ji->code_mp;
      mono_code_manager_destroy (D.34252);
      <D.34251>:
      monoeg_g_free (ji);
    }
  finally
    {
      iter = {CLOBBER};
      jlist = {CLOBBER};
    }
}


mini_thread_cleanup (struct MonoInternalThread * thread)
{
  struct MonoInternalThread * D.34258;
  struct MonoLMF * D.34261;
  struct MonoJitTlsData * jit_tls;

  jit_tls = thread->jit_data;
  if (jit_tls != 0B) goto <D.34256>; else goto <D.34257>;
  <D.34256>:
  D.34258 = mono_thread_internal_current ();
  if (D.34258 == thread) goto <D.34259>; else goto <D.34260>;
  <D.34259>:
  mono_set_jit_tls (0B);
  <D.34260>:
  D.34261 = mono_get_lmf ();
  if (D.34261 != 0B) goto <D.34262>; else goto <D.34263>;
  <D.34262>:
  mono_set_lmf (0B);
  mono_set_lmf_addr (0B);
  <D.34263>:
  free_jit_tls_data (jit_tls);
  thread->jit_data = 0B;
  <D.34257>:
}


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

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


mini_get_imt_trampoline (int slot_index)
{
  void * D.34265;
  int D.34266;

  D.34266 = slot_index + -19;
  D.34265 = mini_get_vtable_trampoline (D.34266);
  return D.34265;
}


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

  D.34268 = descr;
  return D.34268;
}


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

  D.34270 = addr;
  return D.34270;
}


mini_parse_debug_options ()
{
  int D.29071;
  int iftmp.229;
  int D.29070;
  const char[14] * D.34277;
  unsigned char D.34278;
  int D.34279;
  unsigned char D.34280;
  int D.34281;
  _Bool D.34282;
  _Bool D.34283;
  _Bool D.34284;
  const unsigned char * D.34287;
  unsigned char D.34288;
  int D.34289;
  const unsigned char * D.34290;
  unsigned char D.34291;
  int D.34292;
  _Bool D.34293;
  _Bool D.34294;
  const unsigned char * D.34297;
  unsigned char D.34298;
  int D.34299;
  const unsigned char * D.34300;
  unsigned char D.34301;
  int D.34302;
  _Bool D.34303;
  _Bool D.34304;
  const unsigned char * D.34307;
  unsigned char D.34308;
  int D.34309;
  const unsigned char * D.34310;
  unsigned char D.34311;
  int D.34312;
  int D.29080;
  int iftmp.230;
  int D.29079;
  const char[15] * D.34320;
  unsigned char D.34321;
  int D.34322;
  unsigned char D.34323;
  int D.34324;
  _Bool D.34325;
  _Bool D.34326;
  _Bool D.34327;
  const unsigned char * D.34330;
  unsigned char D.34331;
  int D.34332;
  const unsigned char * D.34333;
  unsigned char D.34334;
  int D.34335;
  _Bool D.34336;
  _Bool D.34337;
  const unsigned char * D.34340;
  unsigned char D.34341;
  int D.34342;
  const unsigned char * D.34343;
  unsigned char D.34344;
  int D.34345;
  _Bool D.34346;
  _Bool D.34347;
  const unsigned char * D.34350;
  unsigned char D.34351;
  int D.34352;
  const unsigned char * D.34353;
  unsigned char D.34354;
  int D.34355;
  int D.29089;
  int iftmp.231;
  int D.29088;
  const char[27] * D.34363;
  unsigned char D.34364;
  int D.34365;
  unsigned char D.34366;
  int D.34367;
  _Bool D.34368;
  _Bool D.34369;
  _Bool D.34370;
  const unsigned char * D.34373;
  unsigned char D.34374;
  int D.34375;
  const unsigned char * D.34376;
  unsigned char D.34377;
  int D.34378;
  _Bool D.34379;
  _Bool D.34380;
  const unsigned char * D.34383;
  unsigned char D.34384;
  int D.34385;
  const unsigned char * D.34386;
  unsigned char D.34387;
  int D.34388;
  _Bool D.34389;
  _Bool D.34390;
  const unsigned char * D.34393;
  unsigned char D.34394;
  int D.34395;
  const unsigned char * D.34396;
  unsigned char D.34397;
  int D.34398;
  int D.29098;
  int iftmp.232;
  int D.29097;
  const char[24] * D.34406;
  unsigned char D.34407;
  int D.34408;
  unsigned char D.34409;
  int D.34410;
  _Bool D.34411;
  _Bool D.34412;
  _Bool D.34413;
  const unsigned char * D.34416;
  unsigned char D.34417;
  int D.34418;
  const unsigned char * D.34419;
  unsigned char D.34420;
  int D.34421;
  _Bool D.34422;
  _Bool D.34423;
  const unsigned char * D.34426;
  unsigned char D.34427;
  int D.34428;
  const unsigned char * D.34429;
  unsigned char D.34430;
  int D.34431;
  _Bool D.34432;
  _Bool D.34433;
  const unsigned char * D.34436;
  unsigned char D.34437;
  int D.34438;
  const unsigned char * D.34439;
  unsigned char D.34440;
  int D.34441;
  int D.29107;
  int iftmp.233;
  int D.29106;
  const char[20] * D.34449;
  unsigned char D.34450;
  int D.34451;
  unsigned char D.34452;
  int D.34453;
  _Bool D.34454;
  _Bool D.34455;
  _Bool D.34456;
  const unsigned char * D.34459;
  unsigned char D.34460;
  int D.34461;
  const unsigned char * D.34462;
  unsigned char D.34463;
  int D.34464;
  _Bool D.34465;
  _Bool D.34466;
  const unsigned char * D.34469;
  unsigned char D.34470;
  int D.34471;
  const unsigned char * D.34472;
  unsigned char D.34473;
  int D.34474;
  _Bool D.34475;
  _Bool D.34476;
  const unsigned char * D.34479;
  unsigned char D.34480;
  int D.34481;
  const unsigned char * D.34482;
  unsigned char D.34483;
  int D.34484;
  int D.29116;
  int iftmp.234;
  int D.29115;
  const char[17] * D.34492;
  unsigned char D.34493;
  int D.34494;
  unsigned char D.34495;
  int D.34496;
  _Bool D.34497;
  _Bool D.34498;
  _Bool D.34499;
  const unsigned char * D.34502;
  unsigned char D.34503;
  int D.34504;
  const unsigned char * D.34505;
  unsigned char D.34506;
  int D.34507;
  _Bool D.34508;
  _Bool D.34509;
  const unsigned char * D.34512;
  unsigned char D.34513;
  int D.34514;
  const unsigned char * D.34515;
  unsigned char D.34516;
  int D.34517;
  _Bool D.34518;
  _Bool D.34519;
  const unsigned char * D.34522;
  unsigned char D.34523;
  int D.34524;
  const unsigned char * D.34525;
  unsigned char D.34526;
  int D.34527;
  int D.29125;
  int iftmp.235;
  int D.29124;
  const char[19] * D.34535;
  unsigned char D.34536;
  int D.34537;
  unsigned char D.34538;
  int D.34539;
  _Bool D.34540;
  _Bool D.34541;
  _Bool D.34542;
  const unsigned char * D.34545;
  unsigned char D.34546;
  int D.34547;
  const unsigned char * D.34548;
  unsigned char D.34549;
  int D.34550;
  _Bool D.34551;
  _Bool D.34552;
  const unsigned char * D.34555;
  unsigned char D.34556;
  int D.34557;
  const unsigned char * D.34558;
  unsigned char D.34559;
  int D.34560;
  _Bool D.34561;
  _Bool D.34562;
  const unsigned char * D.34565;
  unsigned char D.34566;
  int D.34567;
  const unsigned char * D.34568;
  unsigned char D.34569;
  int D.34570;
  int D.29134;
  int iftmp.236;
  int D.29133;
  const char[21] * D.34578;
  unsigned char D.34579;
  int D.34580;
  unsigned char D.34581;
  int D.34582;
  _Bool D.34583;
  _Bool D.34584;
  _Bool D.34585;
  const unsigned char * D.34588;
  unsigned char D.34589;
  int D.34590;
  const unsigned char * D.34591;
  unsigned char D.34592;
  int D.34593;
  _Bool D.34594;
  _Bool D.34595;
  const unsigned char * D.34598;
  unsigned char D.34599;
  int D.34600;
  const unsigned char * D.34601;
  unsigned char D.34602;
  int D.34603;
  _Bool D.34604;
  _Bool D.34605;
  const unsigned char * D.34608;
  unsigned char D.34609;
  int D.34610;
  const unsigned char * D.34611;
  unsigned char D.34612;
  int D.34613;
  int D.29143;
  int iftmp.237;
  int D.29142;
  const char[18] * D.34621;
  unsigned char D.34622;
  int D.34623;
  unsigned char D.34624;
  int D.34625;
  _Bool D.34626;
  _Bool D.34627;
  _Bool D.34628;
  const unsigned char * D.34631;
  unsigned char D.34632;
  int D.34633;
  const unsigned char * D.34634;
  unsigned char D.34635;
  int D.34636;
  _Bool D.34637;
  _Bool D.34638;
  const unsigned char * D.34641;
  unsigned char D.34642;
  int D.34643;
  const unsigned char * D.34644;
  unsigned char D.34645;
  int D.34646;
  _Bool D.34647;
  _Bool D.34648;
  const unsigned char * D.34651;
  unsigned char D.34652;
  int D.34653;
  const unsigned char * D.34654;
  unsigned char D.34655;
  int D.34656;
  int D.29152;
  int iftmp.238;
  int D.29151;
  const char[19] * D.34664;
  unsigned char D.34665;
  int D.34666;
  unsigned char D.34667;
  int D.34668;
  _Bool D.34669;
  _Bool D.34670;
  _Bool D.34671;
  const unsigned char * D.34674;
  unsigned char D.34675;
  int D.34676;
  const unsigned char * D.34677;
  unsigned char D.34678;
  int D.34679;
  _Bool D.34680;
  _Bool D.34681;
  const unsigned char * D.34684;
  unsigned char D.34685;
  int D.34686;
  const unsigned char * D.34687;
  unsigned char D.34688;
  int D.34689;
  _Bool D.34690;
  _Bool D.34691;
  const unsigned char * D.34694;
  unsigned char D.34695;
  int D.34696;
  const unsigned char * D.34697;
  unsigned char D.34698;
  int D.34699;
  int D.29161;
  int iftmp.239;
  int D.29160;
  const char[4] * D.34707;
  unsigned char D.34708;
  int D.34709;
  unsigned char D.34710;
  int D.34711;
  _Bool D.34712;
  _Bool D.34713;
  _Bool D.34714;
  const unsigned char * D.34717;
  unsigned char D.34718;
  int D.34719;
  const unsigned char * D.34720;
  unsigned char D.34721;
  int D.34722;
  _Bool D.34723;
  _Bool D.34724;
  const unsigned char * D.34727;
  unsigned char D.34728;
  int D.34729;
  const unsigned char * D.34730;
  unsigned char D.34731;
  int D.34732;
  _Bool D.34733;
  _Bool D.34734;
  const unsigned char * D.34737;
  unsigned char D.34738;
  int D.34739;
  const unsigned char * D.34740;
  unsigned char D.34741;
  int D.34742;
  int D.29170;
  int iftmp.240;
  int D.29169;
  const char[21] * D.34750;
  unsigned char D.34751;
  int D.34752;
  unsigned char D.34753;
  int D.34754;
  _Bool D.34755;
  _Bool D.34756;
  _Bool D.34757;
  const unsigned char * D.34760;
  unsigned char D.34761;
  int D.34762;
  const unsigned char * D.34763;
  unsigned char D.34764;
  int D.34765;
  _Bool D.34766;
  _Bool D.34767;
  const unsigned char * D.34770;
  unsigned char D.34771;
  int D.34772;
  const unsigned char * D.34773;
  unsigned char D.34774;
  int D.34775;
  _Bool D.34776;
  _Bool D.34777;
  const unsigned char * D.34780;
  unsigned char D.34781;
  int D.34782;
  const unsigned char * D.34783;
  unsigned char D.34784;
  int D.34785;
  int D.29179;
  int iftmp.241;
  int D.29178;
  const char[15] * D.34793;
  unsigned char D.34794;
  int D.34795;
  unsigned char D.34796;
  int D.34797;
  _Bool D.34798;
  _Bool D.34799;
  _Bool D.34800;
  const unsigned char * D.34803;
  unsigned char D.34804;
  int D.34805;
  const unsigned char * D.34806;
  unsigned char D.34807;
  int D.34808;
  _Bool D.34809;
  _Bool D.34810;
  const unsigned char * D.34813;
  unsigned char D.34814;
  int D.34815;
  const unsigned char * D.34816;
  unsigned char D.34817;
  int D.34818;
  _Bool D.34819;
  _Bool D.34820;
  const unsigned char * D.34823;
  unsigned char D.34824;
  int D.34825;
  const unsigned char * D.34826;
  unsigned char D.34827;
  int D.34828;
  int D.29188;
  int iftmp.242;
  int D.29187;
  const char[12] * D.34836;
  unsigned char D.34837;
  int D.34838;
  unsigned char D.34839;
  int D.34840;
  _Bool D.34841;
  _Bool D.34842;
  _Bool D.34843;
  const unsigned char * D.34846;
  unsigned char D.34847;
  int D.34848;
  const unsigned char * D.34849;
  unsigned char D.34850;
  int D.34851;
  _Bool D.34852;
  _Bool D.34853;
  const unsigned char * D.34856;
  unsigned char D.34857;
  int D.34858;
  const unsigned char * D.34859;
  unsigned char D.34860;
  int D.34861;
  _Bool D.34862;
  _Bool D.34863;
  const unsigned char * D.34866;
  unsigned char D.34867;
  int D.34868;
  const unsigned char * D.34869;
  unsigned char D.34870;
  int D.34871;
  int D.29197;
  int iftmp.243;
  int D.29196;
  const char[6] * D.34879;
  unsigned char D.34880;
  int D.34881;
  unsigned char D.34882;
  int D.34883;
  _Bool D.34884;
  _Bool D.34885;
  _Bool D.34886;
  const unsigned char * D.34889;
  unsigned char D.34890;
  int D.34891;
  const unsigned char * D.34892;
  unsigned char D.34893;
  int D.34894;
  _Bool D.34895;
  _Bool D.34896;
  const unsigned char * D.34899;
  unsigned char D.34900;
  int D.34901;
  const unsigned char * D.34902;
  unsigned char D.34903;
  int D.34904;
  _Bool D.34905;
  _Bool D.34906;
  const unsigned char * D.34909;
  unsigned char D.34910;
  int D.34911;
  const unsigned char * D.34912;
  unsigned char D.34913;
  int D.34914;
  int D.29206;
  int iftmp.244;
  int D.29205;
  const char[17] * D.34922;
  unsigned char D.34923;
  int D.34924;
  unsigned char D.34925;
  int D.34926;
  _Bool D.34927;
  _Bool D.34928;
  _Bool D.34929;
  const unsigned char * D.34932;
  unsigned char D.34933;
  int D.34934;
  const unsigned char * D.34935;
  unsigned char D.34936;
  int D.34937;
  _Bool D.34938;
  _Bool D.34939;
  const unsigned char * D.34942;
  unsigned char D.34943;
  int D.34944;
  const unsigned char * D.34945;
  unsigned char D.34946;
  int D.34947;
  _Bool D.34948;
  _Bool D.34949;
  const unsigned char * D.34952;
  unsigned char D.34953;
  int D.34954;
  const unsigned char * D.34955;
  unsigned char D.34956;
  int D.34957;
  struct _IO_FILE * stderr.245;
  gchar * D.34964;
  const char * options;
  gchar * * args;
  gchar * * ptr;

  options = monoeg_g_getenv ("MONO_DEBUG");
  if (options == 0B) goto <D.34272>; else goto <D.34273>;
  <D.34272>:
  return;
  <D.34273>:
  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.29208>;
  <D.29207>:
  {
    const char * arg;

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

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

        __s2 = arg;
        D.34277 = "handle-sigint";
        D.34278 = MEM[(const unsigned char *)D.34277];
        D.34279 = (int) D.34278;
        D.34280 = *__s2;
        D.34281 = (int) D.34280;
        __result = D.34279 - D.34281;
        {
          D.34282 = __s2_len != 0;
          D.34283 = __result == 0;
          D.34284 = D.34282 & D.34283;
          if (D.34284 != 0) goto <D.34285>; else goto <D.34286>;
          <D.34285>:
          D.34287 = &MEM[(void *)"handle-sigint" + 1B];
          D.34288 = *D.34287;
          D.34289 = (int) D.34288;
          D.34290 = __s2 + 1;
          D.34291 = *D.34290;
          D.34292 = (int) D.34291;
          __result = D.34289 - D.34292;
          D.34293 = __s2_len > 1;
          D.34283 = __result == 0;
          D.34294 = D.34293 & D.34283;
          if (D.34294 != 0) goto <D.34295>; else goto <D.34296>;
          <D.34295>:
          D.34297 = &MEM[(void *)"handle-sigint" + 2B];
          D.34298 = *D.34297;
          D.34299 = (int) D.34298;
          D.34300 = __s2 + 2;
          D.34301 = *D.34300;
          D.34302 = (int) D.34301;
          __result = D.34299 - D.34302;
          D.34303 = __s2_len > 2;
          D.34283 = __result == 0;
          D.34304 = D.34303 & D.34283;
          if (D.34304 != 0) goto <D.34305>; else goto <D.34306>;
          <D.34305>:
          D.34307 = &MEM[(void *)"handle-sigint" + 3B];
          D.34308 = *D.34307;
          D.34309 = (int) D.34308;
          D.34310 = __s2 + 3;
          D.34311 = *D.34310;
          D.34312 = (int) D.34311;
          __result = D.34309 - D.34312;
          <D.34306>:
          <D.34296>:
          <D.34286>:
        }
        D.29070 = __result;
      }
      iftmp.229 = -D.29070;
      goto <D.34313>;
      <D.34276>:
      iftmp.229 = __builtin_strcmp (arg, "handle-sigint");
      <D.34313>:
      D.29071 = iftmp.229;
    }
    if (D.29071 == 0) goto <D.34314>; else goto <D.34315>;
    <D.34314>:
    debug_options.handle_sigint = 1;
    goto <D.34316>;
    <D.34315>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34320 = "keep-delegates";
        D.34321 = MEM[(const unsigned char *)D.34320];
        D.34322 = (int) D.34321;
        D.34323 = *__s2;
        D.34324 = (int) D.34323;
        __result = D.34322 - D.34324;
        {
          D.34325 = __s2_len != 0;
          D.34326 = __result == 0;
          D.34327 = D.34325 & D.34326;
          if (D.34327 != 0) goto <D.34328>; else goto <D.34329>;
          <D.34328>:
          D.34330 = &MEM[(void *)"keep-delegates" + 1B];
          D.34331 = *D.34330;
          D.34332 = (int) D.34331;
          D.34333 = __s2 + 1;
          D.34334 = *D.34333;
          D.34335 = (int) D.34334;
          __result = D.34332 - D.34335;
          D.34336 = __s2_len > 1;
          D.34326 = __result == 0;
          D.34337 = D.34336 & D.34326;
          if (D.34337 != 0) goto <D.34338>; else goto <D.34339>;
          <D.34338>:
          D.34340 = &MEM[(void *)"keep-delegates" + 2B];
          D.34341 = *D.34340;
          D.34342 = (int) D.34341;
          D.34343 = __s2 + 2;
          D.34344 = *D.34343;
          D.34345 = (int) D.34344;
          __result = D.34342 - D.34345;
          D.34346 = __s2_len > 2;
          D.34326 = __result == 0;
          D.34347 = D.34346 & D.34326;
          if (D.34347 != 0) goto <D.34348>; else goto <D.34349>;
          <D.34348>:
          D.34350 = &MEM[(void *)"keep-delegates" + 3B];
          D.34351 = *D.34350;
          D.34352 = (int) D.34351;
          D.34353 = __s2 + 3;
          D.34354 = *D.34353;
          D.34355 = (int) D.34354;
          __result = D.34352 - D.34355;
          <D.34349>:
          <D.34339>:
          <D.34329>:
        }
        D.29079 = __result;
      }
      iftmp.230 = -D.29079;
      goto <D.34356>;
      <D.34319>:
      iftmp.230 = __builtin_strcmp (arg, "keep-delegates");
      <D.34356>:
      D.29080 = iftmp.230;
    }
    if (D.29080 == 0) goto <D.34357>; else goto <D.34358>;
    <D.34357>:
    debug_options.keep_delegates = 1;
    goto <D.34359>;
    <D.34358>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34363 = "reverse-pinvoke-exceptions";
        D.34364 = MEM[(const unsigned char *)D.34363];
        D.34365 = (int) D.34364;
        D.34366 = *__s2;
        D.34367 = (int) D.34366;
        __result = D.34365 - D.34367;
        {
          D.34368 = __s2_len != 0;
          D.34369 = __result == 0;
          D.34370 = D.34368 & D.34369;
          if (D.34370 != 0) goto <D.34371>; else goto <D.34372>;
          <D.34371>:
          D.34373 = &MEM[(void *)"reverse-pinvoke-exceptions" + 1B];
          D.34374 = *D.34373;
          D.34375 = (int) D.34374;
          D.34376 = __s2 + 1;
          D.34377 = *D.34376;
          D.34378 = (int) D.34377;
          __result = D.34375 - D.34378;
          D.34379 = __s2_len > 1;
          D.34369 = __result == 0;
          D.34380 = D.34379 & D.34369;
          if (D.34380 != 0) goto <D.34381>; else goto <D.34382>;
          <D.34381>:
          D.34383 = &MEM[(void *)"reverse-pinvoke-exceptions" + 2B];
          D.34384 = *D.34383;
          D.34385 = (int) D.34384;
          D.34386 = __s2 + 2;
          D.34387 = *D.34386;
          D.34388 = (int) D.34387;
          __result = D.34385 - D.34388;
          D.34389 = __s2_len > 2;
          D.34369 = __result == 0;
          D.34390 = D.34389 & D.34369;
          if (D.34390 != 0) goto <D.34391>; else goto <D.34392>;
          <D.34391>:
          D.34393 = &MEM[(void *)"reverse-pinvoke-exceptions" + 3B];
          D.34394 = *D.34393;
          D.34395 = (int) D.34394;
          D.34396 = __s2 + 3;
          D.34397 = *D.34396;
          D.34398 = (int) D.34397;
          __result = D.34395 - D.34398;
          <D.34392>:
          <D.34382>:
          <D.34372>:
        }
        D.29088 = __result;
      }
      iftmp.231 = -D.29088;
      goto <D.34399>;
      <D.34362>:
      iftmp.231 = __builtin_strcmp (arg, "reverse-pinvoke-exceptions");
      <D.34399>:
      D.29089 = iftmp.231;
    }
    if (D.29089 == 0) goto <D.34400>; else goto <D.34401>;
    <D.34400>:
    debug_options.reverse_pinvoke_exceptions = 1;
    goto <D.34402>;
    <D.34401>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34406 = "collect-pagefault-stats";
        D.34407 = MEM[(const unsigned char *)D.34406];
        D.34408 = (int) D.34407;
        D.34409 = *__s2;
        D.34410 = (int) D.34409;
        __result = D.34408 - D.34410;
        {
          D.34411 = __s2_len != 0;
          D.34412 = __result == 0;
          D.34413 = D.34411 & D.34412;
          if (D.34413 != 0) goto <D.34414>; else goto <D.34415>;
          <D.34414>:
          D.34416 = &MEM[(void *)"collect-pagefault-stats" + 1B];
          D.34417 = *D.34416;
          D.34418 = (int) D.34417;
          D.34419 = __s2 + 1;
          D.34420 = *D.34419;
          D.34421 = (int) D.34420;
          __result = D.34418 - D.34421;
          D.34422 = __s2_len > 1;
          D.34412 = __result == 0;
          D.34423 = D.34422 & D.34412;
          if (D.34423 != 0) goto <D.34424>; else goto <D.34425>;
          <D.34424>:
          D.34426 = &MEM[(void *)"collect-pagefault-stats" + 2B];
          D.34427 = *D.34426;
          D.34428 = (int) D.34427;
          D.34429 = __s2 + 2;
          D.34430 = *D.34429;
          D.34431 = (int) D.34430;
          __result = D.34428 - D.34431;
          D.34432 = __s2_len > 2;
          D.34412 = __result == 0;
          D.34433 = D.34432 & D.34412;
          if (D.34433 != 0) goto <D.34434>; else goto <D.34435>;
          <D.34434>:
          D.34436 = &MEM[(void *)"collect-pagefault-stats" + 3B];
          D.34437 = *D.34436;
          D.34438 = (int) D.34437;
          D.34439 = __s2 + 3;
          D.34440 = *D.34439;
          D.34441 = (int) D.34440;
          __result = D.34438 - D.34441;
          <D.34435>:
          <D.34425>:
          <D.34415>:
        }
        D.29097 = __result;
      }
      iftmp.232 = -D.29097;
      goto <D.34442>;
      <D.34405>:
      iftmp.232 = __builtin_strcmp (arg, "collect-pagefault-stats");
      <D.34442>:
      D.29098 = iftmp.232;
    }
    if (D.29098 == 0) goto <D.34443>; else goto <D.34444>;
    <D.34443>:
    debug_options.collect_pagefault_stats = 1;
    goto <D.34445>;
    <D.34444>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34449 = "break-on-unverified";
        D.34450 = MEM[(const unsigned char *)D.34449];
        D.34451 = (int) D.34450;
        D.34452 = *__s2;
        D.34453 = (int) D.34452;
        __result = D.34451 - D.34453;
        {
          D.34454 = __s2_len != 0;
          D.34455 = __result == 0;
          D.34456 = D.34454 & D.34455;
          if (D.34456 != 0) goto <D.34457>; else goto <D.34458>;
          <D.34457>:
          D.34459 = &MEM[(void *)"break-on-unverified" + 1B];
          D.34460 = *D.34459;
          D.34461 = (int) D.34460;
          D.34462 = __s2 + 1;
          D.34463 = *D.34462;
          D.34464 = (int) D.34463;
          __result = D.34461 - D.34464;
          D.34465 = __s2_len > 1;
          D.34455 = __result == 0;
          D.34466 = D.34465 & D.34455;
          if (D.34466 != 0) goto <D.34467>; else goto <D.34468>;
          <D.34467>:
          D.34469 = &MEM[(void *)"break-on-unverified" + 2B];
          D.34470 = *D.34469;
          D.34471 = (int) D.34470;
          D.34472 = __s2 + 2;
          D.34473 = *D.34472;
          D.34474 = (int) D.34473;
          __result = D.34471 - D.34474;
          D.34475 = __s2_len > 2;
          D.34455 = __result == 0;
          D.34476 = D.34475 & D.34455;
          if (D.34476 != 0) goto <D.34477>; else goto <D.34478>;
          <D.34477>:
          D.34479 = &MEM[(void *)"break-on-unverified" + 3B];
          D.34480 = *D.34479;
          D.34481 = (int) D.34480;
          D.34482 = __s2 + 3;
          D.34483 = *D.34482;
          D.34484 = (int) D.34483;
          __result = D.34481 - D.34484;
          <D.34478>:
          <D.34468>:
          <D.34458>:
        }
        D.29106 = __result;
      }
      iftmp.233 = -D.29106;
      goto <D.34485>;
      <D.34448>:
      iftmp.233 = __builtin_strcmp (arg, "break-on-unverified");
      <D.34485>:
      D.29107 = iftmp.233;
    }
    if (D.29107 == 0) goto <D.34486>; else goto <D.34487>;
    <D.34486>:
    debug_options.break_on_unverified = 1;
    goto <D.34488>;
    <D.34487>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34492 = "no-gdb-backtrace";
        D.34493 = MEM[(const unsigned char *)D.34492];
        D.34494 = (int) D.34493;
        D.34495 = *__s2;
        D.34496 = (int) D.34495;
        __result = D.34494 - D.34496;
        {
          D.34497 = __s2_len != 0;
          D.34498 = __result == 0;
          D.34499 = D.34497 & D.34498;
          if (D.34499 != 0) goto <D.34500>; else goto <D.34501>;
          <D.34500>:
          D.34502 = &MEM[(void *)"no-gdb-backtrace" + 1B];
          D.34503 = *D.34502;
          D.34504 = (int) D.34503;
          D.34505 = __s2 + 1;
          D.34506 = *D.34505;
          D.34507 = (int) D.34506;
          __result = D.34504 - D.34507;
          D.34508 = __s2_len > 1;
          D.34498 = __result == 0;
          D.34509 = D.34508 & D.34498;
          if (D.34509 != 0) goto <D.34510>; else goto <D.34511>;
          <D.34510>:
          D.34512 = &MEM[(void *)"no-gdb-backtrace" + 2B];
          D.34513 = *D.34512;
          D.34514 = (int) D.34513;
          D.34515 = __s2 + 2;
          D.34516 = *D.34515;
          D.34517 = (int) D.34516;
          __result = D.34514 - D.34517;
          D.34518 = __s2_len > 2;
          D.34498 = __result == 0;
          D.34519 = D.34518 & D.34498;
          if (D.34519 != 0) goto <D.34520>; else goto <D.34521>;
          <D.34520>:
          D.34522 = &MEM[(void *)"no-gdb-backtrace" + 3B];
          D.34523 = *D.34522;
          D.34524 = (int) D.34523;
          D.34525 = __s2 + 3;
          D.34526 = *D.34525;
          D.34527 = (int) D.34526;
          __result = D.34524 - D.34527;
          <D.34521>:
          <D.34511>:
          <D.34501>:
        }
        D.29115 = __result;
      }
      iftmp.234 = -D.29115;
      goto <D.34528>;
      <D.34491>:
      iftmp.234 = __builtin_strcmp (arg, "no-gdb-backtrace");
      <D.34528>:
      D.29116 = iftmp.234;
    }
    if (D.29116 == 0) goto <D.34529>; else goto <D.34530>;
    <D.34529>:
    debug_options.no_gdb_backtrace = 1;
    goto <D.34531>;
    <D.34530>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34535 = "suspend-on-sigsegv";
        D.34536 = MEM[(const unsigned char *)D.34535];
        D.34537 = (int) D.34536;
        D.34538 = *__s2;
        D.34539 = (int) D.34538;
        __result = D.34537 - D.34539;
        {
          D.34540 = __s2_len != 0;
          D.34541 = __result == 0;
          D.34542 = D.34540 & D.34541;
          if (D.34542 != 0) goto <D.34543>; else goto <D.34544>;
          <D.34543>:
          D.34545 = &MEM[(void *)"suspend-on-sigsegv" + 1B];
          D.34546 = *D.34545;
          D.34547 = (int) D.34546;
          D.34548 = __s2 + 1;
          D.34549 = *D.34548;
          D.34550 = (int) D.34549;
          __result = D.34547 - D.34550;
          D.34551 = __s2_len > 1;
          D.34541 = __result == 0;
          D.34552 = D.34551 & D.34541;
          if (D.34552 != 0) goto <D.34553>; else goto <D.34554>;
          <D.34553>:
          D.34555 = &MEM[(void *)"suspend-on-sigsegv" + 2B];
          D.34556 = *D.34555;
          D.34557 = (int) D.34556;
          D.34558 = __s2 + 2;
          D.34559 = *D.34558;
          D.34560 = (int) D.34559;
          __result = D.34557 - D.34560;
          D.34561 = __s2_len > 2;
          D.34541 = __result == 0;
          D.34562 = D.34561 & D.34541;
          if (D.34562 != 0) goto <D.34563>; else goto <D.34564>;
          <D.34563>:
          D.34565 = &MEM[(void *)"suspend-on-sigsegv" + 3B];
          D.34566 = *D.34565;
          D.34567 = (int) D.34566;
          D.34568 = __s2 + 3;
          D.34569 = *D.34568;
          D.34570 = (int) D.34569;
          __result = D.34567 - D.34570;
          <D.34564>:
          <D.34554>:
          <D.34544>:
        }
        D.29124 = __result;
      }
      iftmp.235 = -D.29124;
      goto <D.34571>;
      <D.34534>:
      iftmp.235 = __builtin_strcmp (arg, "suspend-on-sigsegv");
      <D.34571>:
      D.29125 = iftmp.235;
    }
    if (D.29125 == 0) goto <D.34572>; else goto <D.34573>;
    <D.34572>:
    debug_options.suspend_on_sigsegv = 1;
    goto <D.34574>;
    <D.34573>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34578 = "suspend-on-unhandled";
        D.34579 = MEM[(const unsigned char *)D.34578];
        D.34580 = (int) D.34579;
        D.34581 = *__s2;
        D.34582 = (int) D.34581;
        __result = D.34580 - D.34582;
        {
          D.34583 = __s2_len != 0;
          D.34584 = __result == 0;
          D.34585 = D.34583 & D.34584;
          if (D.34585 != 0) goto <D.34586>; else goto <D.34587>;
          <D.34586>:
          D.34588 = &MEM[(void *)"suspend-on-unhandled" + 1B];
          D.34589 = *D.34588;
          D.34590 = (int) D.34589;
          D.34591 = __s2 + 1;
          D.34592 = *D.34591;
          D.34593 = (int) D.34592;
          __result = D.34590 - D.34593;
          D.34594 = __s2_len > 1;
          D.34584 = __result == 0;
          D.34595 = D.34594 & D.34584;
          if (D.34595 != 0) goto <D.34596>; else goto <D.34597>;
          <D.34596>:
          D.34598 = &MEM[(void *)"suspend-on-unhandled" + 2B];
          D.34599 = *D.34598;
          D.34600 = (int) D.34599;
          D.34601 = __s2 + 2;
          D.34602 = *D.34601;
          D.34603 = (int) D.34602;
          __result = D.34600 - D.34603;
          D.34604 = __s2_len > 2;
          D.34584 = __result == 0;
          D.34605 = D.34604 & D.34584;
          if (D.34605 != 0) goto <D.34606>; else goto <D.34607>;
          <D.34606>:
          D.34608 = &MEM[(void *)"suspend-on-unhandled" + 3B];
          D.34609 = *D.34608;
          D.34610 = (int) D.34609;
          D.34611 = __s2 + 3;
          D.34612 = *D.34611;
          D.34613 = (int) D.34612;
          __result = D.34610 - D.34613;
          <D.34607>:
          <D.34597>:
          <D.34587>:
        }
        D.29133 = __result;
      }
      iftmp.236 = -D.29133;
      goto <D.34614>;
      <D.34577>:
      iftmp.236 = __builtin_strcmp (arg, "suspend-on-unhandled");
      <D.34614>:
      D.29134 = iftmp.236;
    }
    if (D.29134 == 0) goto <D.34615>; else goto <D.34616>;
    <D.34615>:
    debug_options.suspend_on_unhandled = 1;
    goto <D.34617>;
    <D.34616>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34621 = "dont-free-domains";
        D.34622 = MEM[(const unsigned char *)D.34621];
        D.34623 = (int) D.34622;
        D.34624 = *__s2;
        D.34625 = (int) D.34624;
        __result = D.34623 - D.34625;
        {
          D.34626 = __s2_len != 0;
          D.34627 = __result == 0;
          D.34628 = D.34626 & D.34627;
          if (D.34628 != 0) goto <D.34629>; else goto <D.34630>;
          <D.34629>:
          D.34631 = &MEM[(void *)"dont-free-domains" + 1B];
          D.34632 = *D.34631;
          D.34633 = (int) D.34632;
          D.34634 = __s2 + 1;
          D.34635 = *D.34634;
          D.34636 = (int) D.34635;
          __result = D.34633 - D.34636;
          D.34637 = __s2_len > 1;
          D.34627 = __result == 0;
          D.34638 = D.34637 & D.34627;
          if (D.34638 != 0) goto <D.34639>; else goto <D.34640>;
          <D.34639>:
          D.34641 = &MEM[(void *)"dont-free-domains" + 2B];
          D.34642 = *D.34641;
          D.34643 = (int) D.34642;
          D.34644 = __s2 + 2;
          D.34645 = *D.34644;
          D.34646 = (int) D.34645;
          __result = D.34643 - D.34646;
          D.34647 = __s2_len > 2;
          D.34627 = __result == 0;
          D.34648 = D.34647 & D.34627;
          if (D.34648 != 0) goto <D.34649>; else goto <D.34650>;
          <D.34649>:
          D.34651 = &MEM[(void *)"dont-free-domains" + 3B];
          D.34652 = *D.34651;
          D.34653 = (int) D.34652;
          D.34654 = __s2 + 3;
          D.34655 = *D.34654;
          D.34656 = (int) D.34655;
          __result = D.34653 - D.34656;
          <D.34650>:
          <D.34640>:
          <D.34630>:
        }
        D.29142 = __result;
      }
      iftmp.237 = -D.29142;
      goto <D.34657>;
      <D.34620>:
      iftmp.237 = __builtin_strcmp (arg, "dont-free-domains");
      <D.34657>:
      D.29143 = iftmp.237;
    }
    if (D.29143 == 0) goto <D.34658>; else goto <D.34659>;
    <D.34658>:
    mono_dont_free_domains = 1;
    goto <D.34660>;
    <D.34659>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34664 = "dyn-runtime-invoke";
        D.34665 = MEM[(const unsigned char *)D.34664];
        D.34666 = (int) D.34665;
        D.34667 = *__s2;
        D.34668 = (int) D.34667;
        __result = D.34666 - D.34668;
        {
          D.34669 = __s2_len != 0;
          D.34670 = __result == 0;
          D.34671 = D.34669 & D.34670;
          if (D.34671 != 0) goto <D.34672>; else goto <D.34673>;
          <D.34672>:
          D.34674 = &MEM[(void *)"dyn-runtime-invoke" + 1B];
          D.34675 = *D.34674;
          D.34676 = (int) D.34675;
          D.34677 = __s2 + 1;
          D.34678 = *D.34677;
          D.34679 = (int) D.34678;
          __result = D.34676 - D.34679;
          D.34680 = __s2_len > 1;
          D.34670 = __result == 0;
          D.34681 = D.34680 & D.34670;
          if (D.34681 != 0) goto <D.34682>; else goto <D.34683>;
          <D.34682>:
          D.34684 = &MEM[(void *)"dyn-runtime-invoke" + 2B];
          D.34685 = *D.34684;
          D.34686 = (int) D.34685;
          D.34687 = __s2 + 2;
          D.34688 = *D.34687;
          D.34689 = (int) D.34688;
          __result = D.34686 - D.34689;
          D.34690 = __s2_len > 2;
          D.34670 = __result == 0;
          D.34691 = D.34690 & D.34670;
          if (D.34691 != 0) goto <D.34692>; else goto <D.34693>;
          <D.34692>:
          D.34694 = &MEM[(void *)"dyn-runtime-invoke" + 3B];
          D.34695 = *D.34694;
          D.34696 = (int) D.34695;
          D.34697 = __s2 + 3;
          D.34698 = *D.34697;
          D.34699 = (int) D.34698;
          __result = D.34696 - D.34699;
          <D.34693>:
          <D.34683>:
          <D.34673>:
        }
        D.29151 = __result;
      }
      iftmp.238 = -D.29151;
      goto <D.34700>;
      <D.34663>:
      iftmp.238 = __builtin_strcmp (arg, "dyn-runtime-invoke");
      <D.34700>:
      D.29152 = iftmp.238;
    }
    if (D.29152 == 0) goto <D.34701>; else goto <D.34702>;
    <D.34701>:
    debug_options.dyn_runtime_invoke = 1;
    goto <D.34703>;
    <D.34702>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34707 = "gdb";
        D.34708 = MEM[(const unsigned char *)D.34707];
        D.34709 = (int) D.34708;
        D.34710 = *__s2;
        D.34711 = (int) D.34710;
        __result = D.34709 - D.34711;
        {
          D.34712 = __s2_len != 0;
          D.34713 = __result == 0;
          D.34714 = D.34712 & D.34713;
          if (D.34714 != 0) goto <D.34715>; else goto <D.34716>;
          <D.34715>:
          D.34717 = &MEM[(void *)"gdb" + 1B];
          D.34718 = *D.34717;
          D.34719 = (int) D.34718;
          D.34720 = __s2 + 1;
          D.34721 = *D.34720;
          D.34722 = (int) D.34721;
          __result = D.34719 - D.34722;
          D.34723 = __s2_len > 1;
          D.34713 = __result == 0;
          D.34724 = D.34723 & D.34713;
          if (D.34724 != 0) goto <D.34725>; else goto <D.34726>;
          <D.34725>:
          D.34727 = &MEM[(void *)"gdb" + 2B];
          D.34728 = *D.34727;
          D.34729 = (int) D.34728;
          D.34730 = __s2 + 2;
          D.34731 = *D.34730;
          D.34732 = (int) D.34731;
          __result = D.34729 - D.34732;
          D.34733 = __s2_len > 2;
          D.34713 = __result == 0;
          D.34734 = D.34733 & D.34713;
          if (D.34734 != 0) goto <D.34735>; else goto <D.34736>;
          <D.34735>:
          D.34737 = &MEM[(void *)"gdb" + 3B];
          D.34738 = *D.34737;
          D.34739 = (int) D.34738;
          D.34740 = __s2 + 3;
          D.34741 = *D.34740;
          D.34742 = (int) D.34741;
          __result = D.34739 - D.34742;
          <D.34736>:
          <D.34726>:
          <D.34716>:
        }
        D.29160 = __result;
      }
      iftmp.239 = -D.29160;
      goto <D.34743>;
      <D.34706>:
      iftmp.239 = __builtin_strcmp (arg, "gdb");
      <D.34743>:
      D.29161 = iftmp.239;
    }
    if (D.29161 == 0) goto <D.34744>; else goto <D.34745>;
    <D.34744>:
    debug_options.gdb = 1;
    goto <D.34746>;
    <D.34745>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34750 = "explicit-null-checks";
        D.34751 = MEM[(const unsigned char *)D.34750];
        D.34752 = (int) D.34751;
        D.34753 = *__s2;
        D.34754 = (int) D.34753;
        __result = D.34752 - D.34754;
        {
          D.34755 = __s2_len != 0;
          D.34756 = __result == 0;
          D.34757 = D.34755 & D.34756;
          if (D.34757 != 0) goto <D.34758>; else goto <D.34759>;
          <D.34758>:
          D.34760 = &MEM[(void *)"explicit-null-checks" + 1B];
          D.34761 = *D.34760;
          D.34762 = (int) D.34761;
          D.34763 = __s2 + 1;
          D.34764 = *D.34763;
          D.34765 = (int) D.34764;
          __result = D.34762 - D.34765;
          D.34766 = __s2_len > 1;
          D.34756 = __result == 0;
          D.34767 = D.34766 & D.34756;
          if (D.34767 != 0) goto <D.34768>; else goto <D.34769>;
          <D.34768>:
          D.34770 = &MEM[(void *)"explicit-null-checks" + 2B];
          D.34771 = *D.34770;
          D.34772 = (int) D.34771;
          D.34773 = __s2 + 2;
          D.34774 = *D.34773;
          D.34775 = (int) D.34774;
          __result = D.34772 - D.34775;
          D.34776 = __s2_len > 2;
          D.34756 = __result == 0;
          D.34777 = D.34776 & D.34756;
          if (D.34777 != 0) goto <D.34778>; else goto <D.34779>;
          <D.34778>:
          D.34780 = &MEM[(void *)"explicit-null-checks" + 3B];
          D.34781 = *D.34780;
          D.34782 = (int) D.34781;
          D.34783 = __s2 + 3;
          D.34784 = *D.34783;
          D.34785 = (int) D.34784;
          __result = D.34782 - D.34785;
          <D.34779>:
          <D.34769>:
          <D.34759>:
        }
        D.29169 = __result;
      }
      iftmp.240 = -D.29169;
      goto <D.34786>;
      <D.34749>:
      iftmp.240 = __builtin_strcmp (arg, "explicit-null-checks");
      <D.34786>:
      D.29170 = iftmp.240;
    }
    if (D.29170 == 0) goto <D.34787>; else goto <D.34788>;
    <D.34787>:
    debug_options.explicit_null_checks = 1;
    goto <D.34789>;
    <D.34788>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34793 = "gen-seq-points";
        D.34794 = MEM[(const unsigned char *)D.34793];
        D.34795 = (int) D.34794;
        D.34796 = *__s2;
        D.34797 = (int) D.34796;
        __result = D.34795 - D.34797;
        {
          D.34798 = __s2_len != 0;
          D.34799 = __result == 0;
          D.34800 = D.34798 & D.34799;
          if (D.34800 != 0) goto <D.34801>; else goto <D.34802>;
          <D.34801>:
          D.34803 = &MEM[(void *)"gen-seq-points" + 1B];
          D.34804 = *D.34803;
          D.34805 = (int) D.34804;
          D.34806 = __s2 + 1;
          D.34807 = *D.34806;
          D.34808 = (int) D.34807;
          __result = D.34805 - D.34808;
          D.34809 = __s2_len > 1;
          D.34799 = __result == 0;
          D.34810 = D.34809 & D.34799;
          if (D.34810 != 0) goto <D.34811>; else goto <D.34812>;
          <D.34811>:
          D.34813 = &MEM[(void *)"gen-seq-points" + 2B];
          D.34814 = *D.34813;
          D.34815 = (int) D.34814;
          D.34816 = __s2 + 2;
          D.34817 = *D.34816;
          D.34818 = (int) D.34817;
          __result = D.34815 - D.34818;
          D.34819 = __s2_len > 2;
          D.34799 = __result == 0;
          D.34820 = D.34819 & D.34799;
          if (D.34820 != 0) goto <D.34821>; else goto <D.34822>;
          <D.34821>:
          D.34823 = &MEM[(void *)"gen-seq-points" + 3B];
          D.34824 = *D.34823;
          D.34825 = (int) D.34824;
          D.34826 = __s2 + 3;
          D.34827 = *D.34826;
          D.34828 = (int) D.34827;
          __result = D.34825 - D.34828;
          <D.34822>:
          <D.34812>:
          <D.34802>:
        }
        D.29178 = __result;
      }
      iftmp.241 = -D.29178;
      goto <D.34829>;
      <D.34792>:
      iftmp.241 = __builtin_strcmp (arg, "gen-seq-points");
      <D.34829>:
      D.29179 = iftmp.241;
    }
    if (D.29179 == 0) goto <D.34830>; else goto <D.34831>;
    <D.34830>:
    debug_options.gen_seq_points = 1;
    goto <D.34832>;
    <D.34831>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34836 = "init-stacks";
        D.34837 = MEM[(const unsigned char *)D.34836];
        D.34838 = (int) D.34837;
        D.34839 = *__s2;
        D.34840 = (int) D.34839;
        __result = D.34838 - D.34840;
        {
          D.34841 = __s2_len != 0;
          D.34842 = __result == 0;
          D.34843 = D.34841 & D.34842;
          if (D.34843 != 0) goto <D.34844>; else goto <D.34845>;
          <D.34844>:
          D.34846 = &MEM[(void *)"init-stacks" + 1B];
          D.34847 = *D.34846;
          D.34848 = (int) D.34847;
          D.34849 = __s2 + 1;
          D.34850 = *D.34849;
          D.34851 = (int) D.34850;
          __result = D.34848 - D.34851;
          D.34852 = __s2_len > 1;
          D.34842 = __result == 0;
          D.34853 = D.34852 & D.34842;
          if (D.34853 != 0) goto <D.34854>; else goto <D.34855>;
          <D.34854>:
          D.34856 = &MEM[(void *)"init-stacks" + 2B];
          D.34857 = *D.34856;
          D.34858 = (int) D.34857;
          D.34859 = __s2 + 2;
          D.34860 = *D.34859;
          D.34861 = (int) D.34860;
          __result = D.34858 - D.34861;
          D.34862 = __s2_len > 2;
          D.34842 = __result == 0;
          D.34863 = D.34862 & D.34842;
          if (D.34863 != 0) goto <D.34864>; else goto <D.34865>;
          <D.34864>:
          D.34866 = &MEM[(void *)"init-stacks" + 3B];
          D.34867 = *D.34866;
          D.34868 = (int) D.34867;
          D.34869 = __s2 + 3;
          D.34870 = *D.34869;
          D.34871 = (int) D.34870;
          __result = D.34868 - D.34871;
          <D.34865>:
          <D.34855>:
          <D.34845>:
        }
        D.29187 = __result;
      }
      iftmp.242 = -D.29187;
      goto <D.34872>;
      <D.34835>:
      iftmp.242 = __builtin_strcmp (arg, "init-stacks");
      <D.34872>:
      D.29188 = iftmp.242;
    }
    if (D.29188 == 0) goto <D.34873>; else goto <D.34874>;
    <D.34873>:
    debug_options.init_stacks = 1;
    goto <D.34875>;
    <D.34874>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34879 = "casts";
        D.34880 = MEM[(const unsigned char *)D.34879];
        D.34881 = (int) D.34880;
        D.34882 = *__s2;
        D.34883 = (int) D.34882;
        __result = D.34881 - D.34883;
        {
          D.34884 = __s2_len != 0;
          D.34885 = __result == 0;
          D.34886 = D.34884 & D.34885;
          if (D.34886 != 0) goto <D.34887>; else goto <D.34888>;
          <D.34887>:
          D.34889 = &MEM[(void *)"casts" + 1B];
          D.34890 = *D.34889;
          D.34891 = (int) D.34890;
          D.34892 = __s2 + 1;
          D.34893 = *D.34892;
          D.34894 = (int) D.34893;
          __result = D.34891 - D.34894;
          D.34895 = __s2_len > 1;
          D.34885 = __result == 0;
          D.34896 = D.34895 & D.34885;
          if (D.34896 != 0) goto <D.34897>; else goto <D.34898>;
          <D.34897>:
          D.34899 = &MEM[(void *)"casts" + 2B];
          D.34900 = *D.34899;
          D.34901 = (int) D.34900;
          D.34902 = __s2 + 2;
          D.34903 = *D.34902;
          D.34904 = (int) D.34903;
          __result = D.34901 - D.34904;
          D.34905 = __s2_len > 2;
          D.34885 = __result == 0;
          D.34906 = D.34905 & D.34885;
          if (D.34906 != 0) goto <D.34907>; else goto <D.34908>;
          <D.34907>:
          D.34909 = &MEM[(void *)"casts" + 3B];
          D.34910 = *D.34909;
          D.34911 = (int) D.34910;
          D.34912 = __s2 + 3;
          D.34913 = *D.34912;
          D.34914 = (int) D.34913;
          __result = D.34911 - D.34914;
          <D.34908>:
          <D.34898>:
          <D.34888>:
        }
        D.29196 = __result;
      }
      iftmp.243 = -D.29196;
      goto <D.34915>;
      <D.34878>:
      iftmp.243 = __builtin_strcmp (arg, "casts");
      <D.34915>:
      D.29197 = iftmp.243;
    }
    if (D.29197 == 0) goto <D.34916>; else goto <D.34917>;
    <D.34916>:
    debug_options.better_cast_details = 1;
    goto <D.34918>;
    <D.34917>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.34922 = "soft-breakpoints";
        D.34923 = MEM[(const unsigned char *)D.34922];
        D.34924 = (int) D.34923;
        D.34925 = *__s2;
        D.34926 = (int) D.34925;
        __result = D.34924 - D.34926;
        {
          D.34927 = __s2_len != 0;
          D.34928 = __result == 0;
          D.34929 = D.34927 & D.34928;
          if (D.34929 != 0) goto <D.34930>; else goto <D.34931>;
          <D.34930>:
          D.34932 = &MEM[(void *)"soft-breakpoints" + 1B];
          D.34933 = *D.34932;
          D.34934 = (int) D.34933;
          D.34935 = __s2 + 1;
          D.34936 = *D.34935;
          D.34937 = (int) D.34936;
          __result = D.34934 - D.34937;
          D.34938 = __s2_len > 1;
          D.34928 = __result == 0;
          D.34939 = D.34938 & D.34928;
          if (D.34939 != 0) goto <D.34940>; else goto <D.34941>;
          <D.34940>:
          D.34942 = &MEM[(void *)"soft-breakpoints" + 2B];
          D.34943 = *D.34942;
          D.34944 = (int) D.34943;
          D.34945 = __s2 + 2;
          D.34946 = *D.34945;
          D.34947 = (int) D.34946;
          __result = D.34944 - D.34947;
          D.34948 = __s2_len > 2;
          D.34928 = __result == 0;
          D.34949 = D.34948 & D.34928;
          if (D.34949 != 0) goto <D.34950>; else goto <D.34951>;
          <D.34950>:
          D.34952 = &MEM[(void *)"soft-breakpoints" + 3B];
          D.34953 = *D.34952;
          D.34954 = (int) D.34953;
          D.34955 = __s2 + 3;
          D.34956 = *D.34955;
          D.34957 = (int) D.34956;
          __result = D.34954 - D.34957;
          <D.34951>:
          <D.34941>:
          <D.34931>:
        }
        D.29205 = __result;
      }
      iftmp.244 = -D.29205;
      goto <D.34958>;
      <D.34921>:
      iftmp.244 = __builtin_strcmp (arg, "soft-breakpoints");
      <D.34958>:
      D.29206 = iftmp.244;
    }
    if (D.29206 == 0) goto <D.34959>; else goto <D.34960>;
    <D.34959>:
    debug_options.soft_breakpoints = 1;
    goto <D.34961>;
    <D.34960>:
    stderr.245 = stderr;
    fprintf (stderr.245, "Invalid option for the MONO_DEBUG env variable: %s\n", arg);
    stderr.245 = stderr;
    fprintf (stderr.245, "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.34961>:
    <D.34918>:
    <D.34875>:
    <D.34832>:
    <D.34789>:
    <D.34746>:
    <D.34703>:
    <D.34660>:
    <D.34617>:
    <D.34574>:
    <D.34531>:
    <D.34488>:
    <D.34445>:
    <D.34402>:
    <D.34359>:
    <D.34316>:
  }
  ptr = ptr + 4;
  <D.29208>:
  if (ptr != 0B) goto <D.34963>; else goto <D.29209>;
  <D.34963>:
  D.34964 = *ptr;
  if (D.34964 != 0B) goto <D.29207>; else goto <D.29209>;
  <D.29209>:
  monoeg_g_strfreev (args);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.34966;
  void (*<Tc1>) (void *) destructor.246;
  int D.34968;
  _Bool D.34969;

  destructor.246 = (void (*<Tc1>) (void *)) destructor;
  D.34968 = pthread_key_create (key, destructor.246);
  D.34969 = D.34968 == 0;
  D.34966 = (int) D.34969;
  return D.34966;
}


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


register_opcode_emulation (int opcode, const char * name, const char * sigstr, void * func, const char * symbol, gboolean no_throw)
{
  unsigned char D.34974;
  unsigned char D.34975;
  _Bool D.34976;
  long int D.34977;
  long int D.34978;
  short unsigned int D.34981;
  _Bool D.34982;
  long int D.34983;
  long int D.34984;
  short int emul_opcode_num.247;
  short int emul_opcode_alloced.248;
  int iftmp.249;
  short int D.34994;
  unsigned short D.34996;
  unsigned short emul_opcode_alloced.250;
  unsigned short D.34998;
  short int emul_opcode_alloced.251;
  struct MonoJitICallInfo * * emul_opcode_map.252;
  unsigned int D.35001;
  unsigned int D.35002;
  void * emul_opcode_map.253;
  short int * emul_opcode_opcodes.254;
  unsigned int D.35005;
  void * emul_opcode_opcodes.255;
  unsigned int D.35007;
  unsigned int D.35008;
  struct MonoJitICallInfo * * D.35009;
  unsigned int D.35010;
  short int * D.35011;
  short int D.35012;
  short int emul_opcode_num.256;
  unsigned short emul_opcode_num.257;
  unsigned short D.35015;
  short int emul_opcode_num.258;
  int D.35017;
  unsigned char D.35018;
  signed char D.35019;
  int D.35020;
  int D.35021;
  signed char D.35022;
  signed char D.35023;
  unsigned char D.35024;
  struct MonoJitICallInfo * info;
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  D.34974 = BIT_FIELD_REF <*sig, 8, 80>;
  D.34975 = D.34974 & 64;
  D.34976 = D.34975 != 0;
  D.34977 = (long int) D.34976;
  D.34978 = __builtin_expect (D.34977, 0);
  if (D.34978 != 0) goto <D.34979>; else goto <D.34980>;
  <D.34979>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2373, "!sig->hasthis");
  <D.34980>:
  D.34981 = sig->param_count;
  D.34982 = D.34981 > 2;
  D.34983 = (long int) D.34982;
  D.34984 = __builtin_expect (D.34983, 0);
  if (D.34984 != 0) goto <D.34985>; else goto <D.34986>;
  <D.34985>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini.c", 2374, "sig->param_count < 3");
  <D.34986>:
  info = mono_register_jit_icall_full (func, name, sig, no_throw, symbol);
  emul_opcode_num.247 = emul_opcode_num;
  emul_opcode_alloced.248 = emul_opcode_alloced;
  if (emul_opcode_num.247 >= emul_opcode_alloced.248) goto <D.34989>; else goto <D.34990>;
  <D.34989>:
  {
    int incr;

    emul_opcode_alloced.248 = emul_opcode_alloced;
    if (emul_opcode_alloced.248 != 0) goto <D.34992>; else goto <D.34993>;
    <D.34992>:
    emul_opcode_alloced.248 = emul_opcode_alloced;
    D.34994 = emul_opcode_alloced.248 / 2;
    iftmp.249 = (int) D.34994;
    goto <D.34995>;
    <D.34993>:
    iftmp.249 = 16;
    <D.34995>:
    incr = iftmp.249;
    D.34996 = (unsigned short) incr;
    emul_opcode_alloced.248 = emul_opcode_alloced;
    emul_opcode_alloced.250 = (unsigned short) emul_opcode_alloced.248;
    D.34998 = D.34996 + emul_opcode_alloced.250;
    emul_opcode_alloced.251 = (short int) D.34998;
    emul_opcode_alloced = emul_opcode_alloced.251;
    emul_opcode_map.252 = emul_opcode_map;
    emul_opcode_alloced.248 = emul_opcode_alloced;
    D.35001 = (unsigned int) emul_opcode_alloced.248;
    D.35002 = D.35001 * 4;
    emul_opcode_map.253 = monoeg_realloc (emul_opcode_map.252, D.35002);
    emul_opcode_map = emul_opcode_map.253;
    emul_opcode_opcodes.254 = emul_opcode_opcodes;
    emul_opcode_alloced.248 = emul_opcode_alloced;
    D.35001 = (unsigned int) emul_opcode_alloced.248;
    D.35005 = D.35001 * 2;
    emul_opcode_opcodes.255 = monoeg_realloc (emul_opcode_opcodes.254, D.35005);
    emul_opcode_opcodes = emul_opcode_opcodes.255;
  }
  <D.34990>:
  emul_opcode_map.252 = emul_opcode_map;
  emul_opcode_num.247 = emul_opcode_num;
  D.35007 = (unsigned int) emul_opcode_num.247;
  D.35008 = D.35007 * 4;
  D.35009 = emul_opcode_map.252 + D.35008;
  *D.35009 = info;
  emul_opcode_opcodes.254 = emul_opcode_opcodes;
  emul_opcode_num.247 = emul_opcode_num;
  D.35007 = (unsigned int) emul_opcode_num.247;
  D.35010 = D.35007 * 2;
  D.35011 = emul_opcode_opcodes.254 + D.35010;
  D.35012 = (short int) opcode;
  *D.35011 = D.35012;
  emul_opcode_num.247 = emul_opcode_num;
  emul_opcode_num.256 = emul_opcode_num.247;
  emul_opcode_num.257 = (unsigned short) emul_opcode_num.256;
  D.35015 = emul_opcode_num.257 + 1;
  emul_opcode_num.258 = (short int) D.35015;
  emul_opcode_num = emul_opcode_num.258;
  D.35017 = opcode >> 6;
  D.35017 = opcode >> 6;
  D.35018 = emul_opcode_hit_cache[D.35017];
  D.35019 = (signed char) D.35018;
  D.35020 = opcode & 7;
  D.35021 = 1 << D.35020;
  D.35022 = (signed char) D.35021;
  D.35023 = D.35019 | D.35022;
  D.35024 = (unsigned char) D.35023;
  emul_opcode_hit_cache[D.35017] = D.35024;
}


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

  if (sigstr != 0B) goto <D.35025>; else goto <D.35026>;
  <D.35025>:
  sig = mono_create_icall_signature (sigstr);
  goto <D.35027>;
  <D.35026>:
  sig = 0B;
  <D.35027>:
  if (save != 0) goto <D.35029>; else goto <D.35030>;
  <D.35029>:
  iftmp.259 = name;
  goto <D.35031>;
  <D.35030>:
  iftmp.259 = 0B;
  <D.35031>:
  mono_register_jit_icall_full (func, name, sig, save, iftmp.259);
}


mini_cleanup (struct MonoDomain * domain)
{
  unsigned int mono_jit_tls_id.260;
  void * D.35033;
  int mono_dont_free_global_codeman.261;
  struct MonoCodeManager * global_codeman.262;
  struct GHashTable * jit_icall_name_hash.263;
  struct MonoJitICallInfo * * emul_opcode_map.264;
  short int * emul_opcode_opcodes.265;
  void * * vtable_trampolines.266;
  struct _IO_FILE * stdout.267;
  struct MonoMethodDesc * mono_inject_async_exc_method.268;

  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.260 = mono_jit_tls_id;
  D.35033 = pthread_getspecific (mono_jit_tls_id.260);
  free_jit_tls_data (D.35033);
  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.261 = mono_dont_free_global_codeman;
  if (mono_dont_free_global_codeman.261 == 0) goto <D.35035>; else goto <D.35036>;
  <D.35035>:
  global_codeman.262 = global_codeman;
  mono_code_manager_destroy (global_codeman.262);
  <D.35036>:
  jit_icall_name_hash.263 = jit_icall_name_hash;
  monoeg_g_hash_table_destroy (jit_icall_name_hash.263);
  emul_opcode_map.264 = emul_opcode_map;
  monoeg_g_free (emul_opcode_map.264);
  emul_opcode_opcodes.265 = emul_opcode_opcodes;
  monoeg_g_free (emul_opcode_opcodes.265);
  vtable_trampolines.266 = vtable_trampolines;
  monoeg_g_free (vtable_trampolines.266);
  mono_arch_cleanup ();
  mono_generic_sharing_cleanup ();
  mono_cleanup ();
  mono_trace_cleanup ();
  stdout.267 = stdout;
  mono_counters_dump (-1, stdout.267);
  mono_inject_async_exc_method.268 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.268 != 0B) goto <D.35044>; else goto <D.35045>;
  <D.35044>:
  mono_inject_async_exc_method.268 = mono_inject_async_exc_method;
  mono_method_desc_free (mono_inject_async_exc_method.268);
  <D.35045>:
  mono_jit_tls_id.260 = mono_jit_tls_id;
  mono_native_tls_free (mono_jit_tls_id.260);
  DeleteCriticalSection (&jit_mutex);
  DeleteCriticalSection (&mono_delegate_section);
  mono_code_manager_cleanup ();
}


print_jit_stats ()
{
  int D.35046;
  int D.35049;
  double D.35050;
  double D.35051;
  char * D.35052;
  int D.35053;
  char * D.35054;
  long unsigned int D.35055;
  long unsigned int D.35056;
  long unsigned int D.35057;
  long unsigned int D.35058;
  long unsigned int D.35059;
  long unsigned int D.35060;
  long unsigned int D.35061;
  struct MonoImage * D.35062;
  struct MonoMemPool * D.35063;
  unsigned int D.35064;
  long unsigned int D.35065;
  long unsigned int D.35066;
  int D.35067;
  long unsigned int D.35068;
  long unsigned int D.35069;
  long unsigned int D.35070;
  long unsigned int D.35071;
  long unsigned int D.35072;
  long unsigned int D.35073;
  long unsigned int D.35074;
  long unsigned int D.35075;
  long unsigned int D.35076;
  long unsigned int D.35077;
  long unsigned int D.35078;
  long unsigned int D.35079;
  long unsigned int D.35080;
  long unsigned int D.35081;
  long unsigned int D.35082;
  long unsigned int D.35083;
  long unsigned int D.35084;
  long unsigned int D.35085;
  long unsigned int D.35086;
  <unnamed type> D.35087;
  int D.35090;
  int D.35091;
  int D.35092;
  int D.35093;
  int D.35094;
  int D.35095;

  D.35046 = mono_jit_stats.enabled;
  if (D.35046 != 0) goto <D.35047>; else goto <D.35048>;
  <D.35047>:
  monoeg_g_print ("Mono Jit statistics\n");
  D.35049 = mono_jit_stats.max_code_size_ratio;
  D.35050 = (double) D.35049;
  D.35051 = D.35050 / 1.0e+2;
  D.35052 = mono_jit_stats.max_ratio_method;
  monoeg_g_print ("Max code size ratio:    %.2f (%s)\n", D.35051, D.35052);
  D.35053 = mono_jit_stats.biggest_method_size;
  D.35054 = mono_jit_stats.biggest_method;
  monoeg_g_print ("Biggest method:         %ld (%s)\n", D.35053, D.35054);
  D.35055 = mono_stats.delegate_creations;
  monoeg_g_print ("Delegates created:      %ld\n", D.35055);
  D.35056 = mono_stats.initialized_class_count;
  monoeg_g_print ("Initialized classes:    %ld\n", D.35056);
  D.35057 = mono_stats.used_class_count;
  monoeg_g_print ("Used classes:           %ld\n", D.35057);
  D.35058 = mono_stats.generic_vtable_count;
  monoeg_g_print ("Generic vtables:        %ld\n", D.35058);
  D.35059 = mono_stats.method_count;
  monoeg_g_print ("Methods:                %ld\n", D.35059);
  D.35060 = mono_stats.class_static_data_size;
  monoeg_g_print ("Static data size:       %ld\n", D.35060);
  D.35061 = mono_stats.class_vtable_size;
  monoeg_g_print ("VTable data size:       %ld\n", D.35061);
  D.35062 = mono_defaults.corlib;
  D.35063 = D.35062->mempool;
  D.35064 = mono_mempool_get_allocated (D.35063);
  monoeg_g_print ("Mscorlib mempool size:  %d\n", D.35064);
  D.35065 = mono_stats.generic_class_count;
  monoeg_g_print ("\nInitialized classes:    %ld\n", D.35065);
  D.35066 = mono_stats.inflated_type_count;
  monoeg_g_print ("Inflated types:         %ld\n", D.35066);
  D.35067 = mono_jit_stats.generic_virtual_invocations;
  monoeg_g_print ("Generics virtual invokes: %ld\n", D.35067);
  D.35068 = mono_stats.generics_sharable_methods;
  monoeg_g_print ("Sharable generic methods: %ld\n", D.35068);
  D.35069 = mono_stats.generics_unsharable_methods;
  monoeg_g_print ("Unsharable generic methods: %ld\n", D.35069);
  D.35070 = mono_stats.generics_shared_methods;
  monoeg_g_print ("Shared generic methods: %ld\n", D.35070);
  D.35071 = mono_stats.gsharedvt_methods;
  monoeg_g_print ("Shared vtype generic methods: %ld\n", D.35071);
  D.35072 = mono_stats.dynamic_code_alloc_count;
  monoeg_g_print ("Dynamic code allocs:    %ld\n", D.35072);
  D.35073 = mono_stats.dynamic_code_bytes_count;
  monoeg_g_print ("Dynamic code bytes:     %ld\n", D.35073);
  D.35074 = mono_stats.dynamic_code_frees_count;
  monoeg_g_print ("Dynamic code frees:     %ld\n", D.35074);
  D.35075 = mono_stats.imt_tables_size;
  monoeg_g_print ("IMT tables size:        %ld\n", D.35075);
  D.35076 = mono_stats.imt_number_of_tables;
  monoeg_g_print ("IMT number of tables:   %ld\n", D.35076);
  D.35077 = mono_stats.imt_number_of_methods;
  monoeg_g_print ("IMT number of methods:  %ld\n", D.35077);
  D.35078 = mono_stats.imt_used_slots;
  monoeg_g_print ("IMT used slots:         %ld\n", D.35078);
  D.35079 = mono_stats.imt_slots_with_collisions;
  monoeg_g_print ("IMT colliding slots:    %ld\n", D.35079);
  D.35080 = mono_stats.imt_max_collisions_in_slot;
  monoeg_g_print ("IMT max collisions:     %ld\n", D.35080);
  D.35081 = mono_stats.imt_method_count_when_max_collisions;
  monoeg_g_print ("IMT methods at max col: %ld\n", D.35081);
  D.35082 = mono_stats.imt_thunks_size;
  monoeg_g_print ("IMT thunks size:        %ld\n", D.35082);
  D.35083 = mono_stats.jit_info_table_insert_count;
  monoeg_g_print ("JIT info table inserts: %ld\n", D.35083);
  D.35084 = mono_stats.jit_info_table_remove_count;
  monoeg_g_print ("JIT info table removes: %ld\n", D.35084);
  D.35085 = mono_stats.jit_info_table_lookup_count;
  monoeg_g_print ("JIT info table lookups: %ld\n", D.35085);
  D.35086 = mono_stats.hazardous_pointer_count;
  monoeg_g_print ("Hazardous pointers:     %ld\n", D.35086);
  D.35087 = mono_security_get_mode ();
  if (D.35087 == 2) goto <D.35088>; else goto <D.35089>;
  <D.35088>:
  D.35090 = mono_jit_stats.cas_declsec_check;
  monoeg_g_print ("\nDecl security check   : %ld\n", D.35090);
  D.35091 = mono_jit_stats.cas_linkdemand;
  monoeg_g_print ("LinkDemand (user)     : %ld\n", D.35091);
  D.35092 = mono_jit_stats.cas_linkdemand_icall;
  monoeg_g_print ("LinkDemand (icall)    : %ld\n", D.35092);
  D.35093 = mono_jit_stats.cas_linkdemand_pinvoke;
  monoeg_g_print ("LinkDemand (pinvoke)  : %ld\n", D.35093);
  D.35094 = mono_jit_stats.cas_linkdemand_aptc;
  monoeg_g_print ("LinkDemand (aptc)     : %ld\n", D.35094);
  D.35095 = mono_jit_stats.cas_demand_generation;
  monoeg_g_print ("Demand (code gen)     : %ld\n", D.35095);
  <D.35089>:
  D.35052 = mono_jit_stats.max_ratio_method;
  monoeg_g_free (D.35052);
  mono_jit_stats.max_ratio_method = 0B;
  D.35054 = mono_jit_stats.biggest_method;
  monoeg_g_free (D.35054);
  mono_jit_stats.biggest_method = 0B;
  <D.35048>:
}


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.35096;
  unsigned int default_opt.269;
  unsigned int default_opt.270;

  D.35096 = ~opts;
  default_opt.269 = default_opt;
  default_opt.270 = D.35096 & default_opt.269;
  default_opt = default_opt.270;
}


mono_set_optimizations (guint32 opts)
{
  int iftmp.271;
  int mono_aot_only.272;
  unsigned int default_opt.273;
  unsigned int D.35106;

  default_opt = opts;
  default_opt_set = 1;
  mono_aot_only.272 = mono_aot_only;
  if (mono_aot_only.272 != 0) goto <D.35100>; else goto <D.35104>;
  <D.35104>:
  default_opt.273 = default_opt;
  D.35106 = default_opt.273 & 16777216;
  if (D.35106 != 0) goto <D.35100>; else goto <D.35101>;
  <D.35100>:
  iftmp.271 = 1;
  goto <D.35102>;
  <D.35101>:
  iftmp.271 = 0;
  <D.35102>:
  mono_set_generic_sharing_vt_supported (iftmp.271);
}


mono_set_verbose_level (guint32 level)
{
  int level.274;

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


mono_get_runtime_build_info ()
{
  const char * mono_build_date.275;
  char * D.35111;

  mono_build_date.275 = mono_build_date;
  if (mono_build_date.275 != 0B) goto <D.35109>; else goto <D.35110>;
  <D.35109>:
  mono_build_date.275 = mono_build_date;
  D.35111 = monoeg_g_strdup_printf ("%s (%s %s)", "3.2.8", "Debian 3.2.8+dfsg-10", mono_build_date.275);
  return D.35111;
  <D.35110>:
  D.35111 = monoeg_g_strdup_printf ("%s (%s)", "3.2.8", "Debian 3.2.8+dfsg-10");
  return D.35111;
}


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.35113;
  int mini_verbose.276;
  const char * D.35119;
  int D.35120;
  int D.35121;
  unsigned int D.35122;
  short unsigned int D.35123;
  int D.35124;
  int D.35125;
  int D.29318;
  int iftmp.277;
  int D.29317;
  const char[9] * D.35133;
  unsigned char D.35134;
  int D.35135;
  unsigned char D.35136;
  int D.35137;
  _Bool D.35138;
  _Bool D.35139;
  _Bool D.35140;
  const unsigned char * D.35143;
  unsigned char D.35144;
  int D.35145;
  const unsigned char * D.35146;
  unsigned char D.35147;
  int D.35148;
  _Bool D.35149;
  _Bool D.35150;
  const unsigned char * D.35153;
  unsigned char D.35154;
  int D.35155;
  const unsigned char * D.35156;
  unsigned char D.35157;
  int D.35158;
  _Bool D.35159;
  _Bool D.35160;
  const unsigned char * D.35163;
  unsigned char D.35164;
  int D.35165;
  const unsigned char * D.35166;
  unsigned char D.35167;
  int D.35168;
  const char * D.35170;
  struct MonoClass * D.35173;
  unsigned char D.35174;
  unsigned char D.35175;
  struct MonoMethodSignature * D.35178;
  unsigned char D.35179;
  unsigned char D.35180;
  int D.35183;
  struct MonoAssembly * * D.35184;
  unsigned int i.278;
  unsigned int D.35186;
  struct MonoAssembly * * D.35187;
  struct MonoAssembly * D.35188;
  int D.35191;
  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.35113 = monoeg_g_hash_table_lookup (assemblies, ass);
  if (D.35113 != 0B) goto <D.35114>; else goto <D.35115>;
  <D.35114>:
  return;
  <D.35115>:
  monoeg_g_hash_table_insert_replace (assemblies, ass, ass, 0);
  mini_verbose.276 = mini_verbose;
  if (mini_verbose.276 > 0) goto <D.35117>; else goto <D.35118>;
  <D.35117>:
  D.35119 = mono_image_get_filename (image);
  printf ("PRECOMPILE: %s.\n", D.35119);
  <D.35118>:
  i = 0;
  goto <D.29320>;
  <D.29319>:
  D.35120 = i + 1;
  D.35121 = D.35120 | 100663296;
  D.35122 = (unsigned int) D.35121;
  method = mono_get_method (image, D.35122, 0B);
  D.35123 = method->flags;
  D.35124 = (int) D.35123;
  D.35125 = D.35124 & 1024;
  if (D.35125 != 0) goto <D.35126>; else goto <D.35127>;
  <D.35126>:
  // predicted unlikely by continue predictor.
  goto <D.29308>;
  <D.35127>:
  count = count + 1;
  mini_verbose.276 = mini_verbose;
  if (mini_verbose.276 > 1) goto <D.35128>; else goto <D.35129>;
  <D.35128>:
  {
    char * desc;

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

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

      __s2 = method->name;
      D.35133 = "Finalize";
      D.35134 = MEM[(const unsigned char *)D.35133];
      D.35135 = (int) D.35134;
      D.35136 = *__s2;
      D.35137 = (int) D.35136;
      __result = D.35135 - D.35137;
      {
        D.35138 = __s2_len != 0;
        D.35139 = __result == 0;
        D.35140 = D.35138 & D.35139;
        if (D.35140 != 0) goto <D.35141>; else goto <D.35142>;
        <D.35141>:
        D.35143 = &MEM[(void *)"Finalize" + 1B];
        D.35144 = *D.35143;
        D.35145 = (int) D.35144;
        D.35146 = __s2 + 1;
        D.35147 = *D.35146;
        D.35148 = (int) D.35147;
        __result = D.35145 - D.35148;
        D.35149 = __s2_len > 1;
        D.35139 = __result == 0;
        D.35150 = D.35149 & D.35139;
        if (D.35150 != 0) goto <D.35151>; else goto <D.35152>;
        <D.35151>:
        D.35153 = &MEM[(void *)"Finalize" + 2B];
        D.35154 = *D.35153;
        D.35155 = (int) D.35154;
        D.35156 = __s2 + 2;
        D.35157 = *D.35156;
        D.35158 = (int) D.35157;
        __result = D.35155 - D.35158;
        D.35159 = __s2_len > 2;
        D.35139 = __result == 0;
        D.35160 = D.35159 & D.35139;
        if (D.35160 != 0) goto <D.35161>; else goto <D.35162>;
        <D.35161>:
        D.35163 = &MEM[(void *)"Finalize" + 3B];
        D.35164 = *D.35163;
        D.35165 = (int) D.35164;
        D.35166 = __s2 + 3;
        D.35167 = *D.35166;
        D.35168 = (int) D.35167;
        __result = D.35165 - D.35168;
        <D.35162>:
        <D.35152>:
        <D.35142>:
      }
      D.29317 = __result;
    }
    iftmp.277 = -D.29317;
    goto <D.35169>;
    <D.35132>:
    D.35170 = method->name;
    iftmp.277 = __builtin_strcmp (D.35170, "Finalize");
    <D.35169>:
    D.29318 = iftmp.277;
  }
  if (D.29318 == 0) goto <D.35171>; else goto <D.35172>;
  <D.35171>:
  invoke = mono_marshal_get_runtime_invoke (method, 0);
  mono_compile_method (invoke);
  <D.35172>:
  D.35173 = method->klass;
  D.35174 = BIT_FIELD_REF <*D.35173, 8, 176>;
  D.35175 = D.35174 & 64;
  if (D.35175 != 0) goto <D.35176>; else goto <D.35177>;
  <D.35176>:
  D.35178 = mono_method_signature (method);
  D.35179 = BIT_FIELD_REF <*D.35178, 8, 80>;
  D.35180 = D.35179 & 64;
  if (D.35180 != 0) goto <D.35181>; else goto <D.35182>;
  <D.35181>:
  invoke = mono_marshal_get_remoting_invoke_with_check (method);
  mono_compile_method (invoke);
  <D.35182>:
  <D.35177>:
  <D.29308>:
  i = i + 1;
  <D.29320>:
  D.35183 = mono_image_get_table_rows (image, 6);
  if (D.35183 > i) goto <D.29319>; else goto <D.29321>;
  <D.29321>:
  i = 0;
  goto <D.29323>;
  <D.29322>:
  mono_assembly_load_reference (image, i);
  D.35184 = image->references;
  i.278 = (unsigned int) i;
  D.35186 = i.278 * 4;
  D.35187 = D.35184 + D.35186;
  D.35188 = *D.35187;
  if (D.35188 != 0B) goto <D.35189>; else goto <D.35190>;
  <D.35189>:
  D.35184 = image->references;
  i.278 = (unsigned int) i;
  D.35186 = i.278 * 4;
  D.35187 = D.35184 + D.35186;
  D.35188 = *D.35187;
  mono_precompile_assembly (D.35188, assemblies);
  <D.35190>:
  i = i + 1;
  <D.29323>:
  D.35191 = mono_image_get_table_rows (image, 35);
  if (D.35191 > i) goto <D.29322>; else goto <D.29324>;
  <D.29324>:
}


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

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


mono_cfg_add_try_hole (struct MonoCompile * cfg, struct MonoExceptionClause * clause, guint8 * start, struct MonoBasicBlock * bb)
{
  struct MonoMemPool * D.35195;
  int start.279;
  unsigned char * D.35197;
  int D.35198;
  int D.35199;
  struct GSList * D.35200;
  struct GSList * D.35201;
  struct TryBlockHole * hole;

  D.35195 = cfg->mempool;
  hole = mono_mempool_alloc (D.35195, 12);
  hole->clause = clause;
  start.279 = (int) start;
  D.35197 = cfg->native_code;
  D.35198 = (int) D.35197;
  D.35199 = start.279 - D.35198;
  hole->start_offset = D.35199;
  hole->basic_block = bb;
  D.35195 = cfg->mempool;
  D.35200 = cfg->try_block_holes;
  D.35201 = g_slist_append_mempool (D.35195, D.35200, hole);
  cfg->try_block_holes = D.35201;
}


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

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


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

  D.35203 = 0;
  return D.35203;
}


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

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


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

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